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

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

@@ -1,215 +0,0 @@
-/**
- * WorkflowNode executes a nested workflow as a node.
- *
- * This allows one workflow to invoke another workflow as a single node,
- * enabling workflow composition and reusability.
- *
- * Features:
- * - Pass input to sub-workflow (with template resolution)
- * - Wait for completion or fire-and-forget
- * - Handle sub-workflow errors
- * - Track execution duration
- */
-export class WorkflowNode {
-    workflowRunner;
-    type = 'workflow';
-    id;
-    config;
-    constructor(definition, workflowRunner) {
-        this.workflowRunner = workflowRunner;
-        this.id = definition.id;
-        this.config = (definition.config ?? {});
-    }
-    async execute(context) {
-        const startTime = Date.now();
-        try {
-            // 1. Get workflow name from config
-            const workflowName = this.config.workflow_name;
-            if (!workflowName) {
-                throw new Error('workflow_name is required in config. Please specify config.workflow_name in the node definition.');
-            }
-            // 2. Resolve input template (may reference previous outputs)
-            // Support both Map (previousOutputs) and Record (nodeOutputs) formats
-            const previousOutputs = context.previousOutputs ?? this.convertToMap((context.nodeOutputs ?? {}));
-            const resolvedInput = this.resolveInput(this.config.input ?? {}, previousOutputs);
-            // 3. Run sub-workflow via workflowRunner
-            const result = await this.workflowRunner.run(workflowName, resolvedInput);
-            // 4. Determine success based on status
-            const success = result.status === 'completed';
-            // 5. Return result
-            return {
-                success,
-                output: result.output,
-                error: success ? undefined : result.error,
-                duration: Date.now() - startTime,
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                output: undefined,
-                error: error instanceof Error ? error : new Error(String(error)),
-                duration: Date.now() - startTime,
-            };
-        }
-    }
-    /**
-     * Convert Record<string, NodeExecutionResult> to Map<string, any>
-     * for compatibility with resolvePath that expects Map format.
-     *
-     * In the Record format, the value is NodeExecutionResult (with output field).
-     * In the Map format, the value is the raw output directly.
-     */
-    convertToMap(nodeOutputs) {
-        const map = new Map();
-        for (const [nodeId, result] of Object.entries(nodeOutputs)) {
-            // Store the entire result for access to both output and success
-            map.set(nodeId, result.output);
-        }
-        return map;
-    }
-    /**
-     * Resolve input template references.
-     * Templates are in the format {{nodeId.output.path}}
-     *
-     * @param input - The input object that may contain template strings
-     * @param previousOutputs - Map of previous node outputs (value is raw output)
-     * @returns The input with template references resolved
-     */
-    resolveInput(input, previousOutputs) {
-        const resolved = {};
-        for (const [key, value] of Object.entries(input)) {
-            resolved[key] = this.resolveValue(value, previousOutputs);
-        }
-        return resolved;
-    }
-    /**
-     * Resolve a value that may contain template references.
-     */
-    resolveValue(value, previousOutputs) {
-        if (typeof value === 'string') {
-            return this.resolveStringTemplate(value, previousOutputs);
-        }
-        if (Array.isArray(value)) {
-            return value.map(item => this.resolveValue(item, previousOutputs));
-        }
-        if (value !== null && typeof value === 'object') {
-            const resolved = {};
-            for (const [k, v] of Object.entries(value)) {
-                resolved[k] = this.resolveValue(v, previousOutputs);
-            }
-            return resolved;
-        }
-        // Return primitive values as-is
-        return value;
-    }
-    /**
-     * Resolve template references in a single string.
-     * Supports format: {{nodeId.output.path}}
-     */
-    resolveStringTemplate(template, previousOutputs) {
-        // Match template patterns like {{nodeId}} or {{nodeId.output.value}}
-        const templatePattern = /\{\{([^}]+)\}\}/g;
-        return template.replace(templatePattern, (match, path) => {
-            const trimmedPath = path.trim();
-            // Try to resolve the path from previous outputs
-            const value = this.resolvePath(trimmedPath, previousOutputs);
-            if (value !== undefined) {
-                return this.stringifyValue(value, match);
-            }
-            // If not found, return the original template string
-            return match;
-        });
-    }
-    /**
-     * Resolve a dot-notation path from previous outputs.
-     * First segment is the node ID, rest is the path within that node's output.
-     */
-    resolvePath(path, previousOutputs) {
-        const segments = path.split('.');
-        if (segments.length === 0) {
-            return undefined;
-        }
-        const nodeId = segments[0];
-        let nodeOutput = previousOutputs.get(nodeId);
-        if (nodeOutput === undefined) {
-            return undefined;
-        }
-        // Extract from wrapper formats (DecoratorNode: {success, output} and AgentNode: {result, metadata})
-        nodeOutput = this.extractFromWrapper(nodeOutput);
-        // If no path beyond node ID, return the extracted value
-        if (segments.length === 1) {
-            return nodeOutput;
-        }
-        // Navigate the path within the node's output
-        // Skip first segment if it's a wrapper property since extractFromWrapper already extracted it
-        let current = nodeOutput;
-        let startIndex = 1;
-        if (segments.length > 1 &&
-            (segments[1] === 'output' || segments[1] === 'result' || segments[1] === 'metadata')) {
-            startIndex = 2;
-        }
-        for (let i = startIndex; i < segments.length; i++) {
-            if (current === null || current === undefined) {
-                return undefined;
-            }
-            current = current[segments[i]];
-        }
-        return current;
-    }
-    /**
-     * Extract the actual output value from wrapper formats.
-     *
-     * Handles:
-     * - AgentNode format: { result, metadata } -> returns result
-     * - DecoratorNode format: { success, output, ... } -> returns output
-     * - Other formats: returns value as-is
-     *
-     * @param value - The value to extract from
-     * @returns The extracted value
-     */
-    extractFromWrapper(value) {
-        if (value === null || value === undefined) {
-            return value;
-        }
-        if (typeof value !== 'object') {
-            return value;
-        }
-        // Check for AgentNode wrapper: { result, metadata }
-        // This is the signature of AgentNode output
-        if ('result' in value && 'metadata' in value) {
-            return value.result;
-        }
-        // Check for DecoratorNode wrapper: { success, output, ... }
-        // This has 'output' but NOT 'result' (that's AgentNode's signature)
-        if ('output' in value) {
-            return value.output;
-        }
-        return value;
-    }
-    /**
-     * Convert a value to string for template replacement.
-     * - If value is undefined, return the original template
-     * - If value is a string, return it directly
-     * - If value is null, return 'null'
-     * - If value is an object or array, serialize to JSON
-     *
-     * @param value - The value to stringify
-     * @param originalTemplate - The original template string (returned if value is undefined)
-     * @returns String representation of the value
-     */
-    stringifyValue(value, originalTemplate) {
-        if (value === undefined) {
-            return originalTemplate;
-        }
-        if (value === null) {
-            return 'null';
-        }
-        if (typeof value === 'string') {
-            return value;
-        }
-        // For objects and arrays, serialize to JSON
-        return JSON.stringify(value);
-    }
-}
-//# sourceMappingURL=workflow-node.js.map

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

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

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

@@ -1,255 +0,0 @@
-import { describe, it, expect, beforeEach, jest } from 'vitest';
-import { WorkflowNode } from "./workflow-node.js";
-// Mock EventBus
-const mockEventBus = {
-    emit: jest.fn(),
-    on: jest.fn(),
-    off: jest.fn(),
-};
-// Mock WorkflowRunner
-const createMockRunner = () => ({
-    run: jest.fn(),
-    getRun: jest.fn(),
-});
-describe('WorkflowNode', () => {
-    let nodeDefinition;
-    let executionContext;
-    let mockRunner;
-    beforeEach(() => {
-        jest.clearAllMocks();
-        nodeDefinition = {
-            id: 'workflow-node-1',
-            type: 'workflow',
-            name: 'Nested Workflow Node',
-            config: {
-                workflow_name: 'sub-workflow',
-                input: { message: 'hello from parent' },
-                wait_complete: true,
-            },
-        };
-        executionContext = {
-            sessionId: 'session-1',
-            nodeOutputs: {},
-            input: {},
-            metadata: {},
-        };
-        mockRunner = createMockRunner();
-    });
-    describe('constructor', () => {
-        it('should create a WorkflowNode with correct type', () => {
-            const workflowNode = new WorkflowNode(nodeDefinition, mockRunner);
-            expect(workflowNode.type).toBe('workflow');
-            expect(workflowNode.id).toBe('workflow-node-1');
-        });
-        it('should create WorkflowNode with minimal config', () => {
-            const minimalDef = {
-                id: 'minimal-node',
-                type: 'workflow',
-                config: {
-                    workflow_name: 'simple-workflow',
-                },
-            };
-            const workflowNode = new WorkflowNode(minimalDef, mockRunner);
-            expect(workflowNode.type).toBe('workflow');
-            expect(workflowNode.id).toBe('minimal-node');
-        });
-    });
-    describe('execute', () => {
-        it('should run sub-workflow successfully', async () => {
-            const completedResult = {
-                runId: 'run_123',
-                status: 'completed',
-                output: { result: 'nested workflow done' },
-            };
-            mockRunner.run.mockResolvedValue(completedResult);
-            const workflowNode = new WorkflowNode(nodeDefinition, mockRunner);
-            const result = await workflowNode.execute(executionContext);
-            expect(result.success).toBe(true);
-            expect(result.output).toEqual({ result: 'nested workflow done' });
-            expect(result.error).toBeUndefined();
-            expect(mockRunner.run).toHaveBeenCalledWith('sub-workflow', {
-                message: 'hello from parent',
-            });
-        });
-        it('should pass input to sub-workflow', async () => {
-            const customInput = { param1: 'value1', param2: 123, nested: { data: 'test' } };
-            nodeDefinition.config.input = customInput;
-            mockRunner.run.mockResolvedValue({
-                runId: 'run_456',
-                status: 'completed',
-                output: { processed: true },
-            });
-            const workflowNode = new WorkflowNode(nodeDefinition, mockRunner);
-            await workflowNode.execute(executionContext);
-            expect(mockRunner.run).toHaveBeenCalledWith('sub-workflow', customInput);
-        });
-        it('should wait for completion when wait_complete=true', async () => {
-            nodeDefinition.config.wait_complete = true;
-            mockRunner.run.mockResolvedValue({
-                runId: 'run_wait',
-                status: 'completed',
-                output: { waited: true },
-            });
-            const workflowNode = new WorkflowNode(nodeDefinition, mockRunner);
-            const result = await workflowNode.execute(executionContext);
-            expect(result.success).toBe(true);
-            expect(result.output).toEqual({ waited: true });
-            // When wait_complete=true, run should return completed status
-            expect(mockRunner.run).toHaveBeenCalled();
-        });
-        it('should not wait for completion when wait_complete=false', async () => {
-            nodeDefinition.config.wait_complete = false;
-            mockRunner.run.mockResolvedValue({
-                runId: 'run_fire',
-                status: 'completed', // Fire-and-forget returns immediately
-                output: { runId: 'run_fire' },
-            });
-            const workflowNode = new WorkflowNode(nodeDefinition, mockRunner);
-            const result = await workflowNode.execute(executionContext);
-            expect(result.success).toBe(true);
-            expect(result.output).toBeDefined();
-            // Should have called run
-            expect(mockRunner.run).toHaveBeenCalled();
-        });
-        it('should handle sub-workflow failure', async () => {
-            mockRunner.run.mockResolvedValue({
-                runId: 'run_fail',
-                status: 'failed',
-                error: 'Sub-workflow execution failed',
-            });
-            const workflowNode = new WorkflowNode(nodeDefinition, mockRunner);
-            const result = await workflowNode.execute(executionContext);
-            expect(result.success).toBe(false);
-            expect(result.error).toBeDefined();
-            expect(result.error).toContain('Sub-workflow execution failed');
-        });
-        it('should handle sub-workflow not found', async () => {
-            mockRunner.run.mockRejectedValue(new Error('Workflow not found: non-existent-workflow'));
-            nodeDefinition.config.workflow_name = 'non-existent-workflow';
-            const workflowNode = new WorkflowNode(nodeDefinition, mockRunner);
-            const result = await workflowNode.execute(executionContext);
-            expect(result.success).toBe(false);
-            expect(result.error).toBeDefined();
-            expect(result.error.message).toContain('Workflow not found');
-        });
-        it('should record execution duration', async () => {
-            mockRunner.run.mockImplementation(async () => {
-                await new Promise(resolve => setTimeout(resolve, 10));
-                return {
-                    runId: 'run_duration',
-                    status: 'completed',
-                    output: { done: true },
-                };
-            });
-            const workflowNode = new WorkflowNode(nodeDefinition, mockRunner);
-            const result = await workflowNode.execute(executionContext);
-            expect(result.duration).toBeGreaterThanOrEqual(0);
-        });
-        it('should resolve template references from previous outputs', async () => {
-            // Set up previous outputs from other nodes
-            // Note: The Map format stores raw outputs directly, so path is {{nodeId.property}}
-            executionContext.previousOutputs = new Map([
-                ['node-0', { value: 'from-node-0' }]
-            ]);
-            // Create node with template reference input
-            const templateNodeDef = {
-                id: 'workflow-node-1',
-                type: 'workflow',
-                name: 'Nested Workflow Node',
-                config: {
-                    workflow_name: 'sub-workflow',
-                    input: {
-                        message: '{{node-0.value}}',
-                    },
-                },
-            };
-            mockRunner.run.mockResolvedValue({
-                runId: 'run_template',
-                status: 'completed',
-                output: { received: 'from-node-0' },
-            });
-            const workflowNode = new WorkflowNode(templateNodeDef, mockRunner);
-            await workflowNode.execute(executionContext);
-            // The input should have template references resolved
-            expect(mockRunner.run).toHaveBeenCalledWith('sub-workflow', {
-                message: 'from-node-0',
-            });
-        });
-        it('should handle unresolved template references gracefully', async () => {
-            nodeDefinition.config.input = {
-                message: '{{non-existent.value}}',
-            };
-            mockRunner.run.mockResolvedValue({
-                runId: 'run_unresolved',
-                status: 'completed',
-                output: {},
-            });
-            const workflowNode = new WorkflowNode(nodeDefinition, mockRunner);
-            await workflowNode.execute(executionContext);
-            // Should pass through unresolved template as-is
-            expect(mockRunner.run).toHaveBeenCalledWith('sub-workflow', {
-                message: '{{non-existent.value}}',
-            });
-        });
-        it('should throw error when workflow_name is missing', async () => {
-            nodeDefinition.config = {}; // No workflow_name specified
-            const workflowNode = new WorkflowNode(nodeDefinition, mockRunner);
-            const result = await workflowNode.execute(executionContext);
-            expect(result.success).toBe(false);
-            expect(result.error).toBeDefined();
-            expect(result.error.message).toContain('workflow_name');
-        });
-        it('should pass metadata to sub-workflow', async () => {
-            executionContext.metadata = {
-                parentRunId: 'parent-123',
-                correlationId: 'corr-456',
-            };
-            mockRunner.run.mockResolvedValue({
-                runId: 'run_meta',
-                status: 'completed',
-                output: {},
-            });
-            const workflowNode = new WorkflowNode(nodeDefinition, mockRunner);
-            await workflowNode.execute(executionContext);
-            expect(mockRunner.run).toHaveBeenCalledWith('sub-workflow', {
-                message: 'hello from parent',
-            });
-        });
-        it('should handle stopped sub-workflow', async () => {
-            mockRunner.run.mockResolvedValue({
-                runId: 'run_stopped',
-                status: 'stopped',
-                error: 'Workflow was stopped',
-            });
-            const workflowNode = new WorkflowNode(nodeDefinition, mockRunner);
-            const result = await workflowNode.execute(executionContext);
-            expect(result.success).toBe(false);
-            expect(result.error).toBeDefined();
-        });
-    });
-    describe('WorkflowRunner interface', () => {
-        it('should use run method to start workflows', async () => {
-            mockRunner.run.mockResolvedValue({
-                runId: 'run_interface',
-                status: 'completed',
-                output: { test: true },
-            });
-            const workflowNode = new WorkflowNode(nodeDefinition, mockRunner);
-            await workflowNode.execute(executionContext);
-            expect(mockRunner.run).toHaveBeenCalledTimes(1);
-        });
-        it('should use getRun method for status checking', async () => {
-            // This test verifies the interface contract
-            mockRunner.getRun.mockResolvedValue({
-                runId: 'run_status',
-                status: 'completed',
-                output: {},
-            });
-            // The interface supports getRun for status checking
-            const status = await mockRunner.getRun('run_status');
-            expect(status).toBeDefined();
-            expect(status?.runId).toBe('run_status');
-        });
-    });
-});
-//# sourceMappingURL=workflow-node.test.js.map

package/dist/core/src/env/workflow/service/index.d.ts

@@ -1,10 +0,0 @@
-/**
- * Service Index - Session-based Workflow Service
- *
- * After refactoring, RunRepository is removed. Workflow runs are managed via SessionComponent.
- */
-export { WorkflowService } from './workflow-service';
-export type { WorkflowRepository, WorkflowEngine, CreateOptions, ListOptions, WorkflowUpdates, WorkflowEngineFactory, SessionInfo, WorkflowSessionMetadata, AgentSessionRef, } from './workflow-service';
-export { WorkflowServiceRegistry, getWorkflowService, registerWorkflowService, } from './registry';
-export type { WorkflowDefinition } from '../types/workflow';
-//# sourceMappingURL=index.d.ts.map

package/dist/core/src/env/workflow/service/index.js

@@ -1,8 +0,0 @@
-/**
- * Service Index - Session-based Workflow Service
- *
- * After refactoring, RunRepository is removed. Workflow runs are managed via SessionComponent.
- */
-export { WorkflowService } from "./workflow-service.js";
-export { WorkflowServiceRegistry, getWorkflowService, registerWorkflowService, } from "./registry.js";
-//# sourceMappingURL=index.js.map

package/dist/core/src/env/workflow/service/registry.d.ts

@@ -1,38 +0,0 @@
-/**
- * Registry - Singleton registry for accessing WorkflowService
- */
-import { WorkflowService } from './workflow-service';
-/**
- * Singleton registry for WorkflowService
- * Provides centralized access to the workflow service instance
- */
-export declare class WorkflowServiceRegistry {
-    private static instance;
-    private service;
-    private constructor();
-    /**
-     * Get the singleton registry instance
-     */
-    static getInstance(): WorkflowServiceRegistry;
-    /**
-     * Register a WorkflowService instance
-     */
-    register(service: WorkflowService): void;
-    /**
-     * Get the registered WorkflowService instance
-     * @throws Error if no service is registered
-     */
-    get(): WorkflowService;
-    /**
-     * Check if a service is registered
-     */
-    isRegistered(): boolean;
-    /**
-     * Reset the registry (primarily for testing)
-     */
-    reset(): void;
-}
-export declare function getWorkflowService(): WorkflowService;
-export declare function registerWorkflowService(service: WorkflowService): void;
-export type { WorkflowService };
-//# sourceMappingURL=registry.d.ts.map

package/dist/core/src/env/workflow/service/registry.js

@@ -1,58 +0,0 @@
-/**
- * Registry - Singleton registry for accessing WorkflowService
- */
-/**
- * Singleton registry for WorkflowService
- * Provides centralized access to the workflow service instance
- */
-export class WorkflowServiceRegistry {
-    static instance;
-    service = null;
-    constructor() { }
-    /**
-     * Get the singleton registry instance
-     */
-    static getInstance() {
-        if (!WorkflowServiceRegistry.instance) {
-            WorkflowServiceRegistry.instance = new WorkflowServiceRegistry();
-        }
-        return WorkflowServiceRegistry.instance;
-    }
-    /**
-     * Register a WorkflowService instance
-     */
-    register(service) {
-        this.service = service;
-    }
-    /**
-     * Get the registered WorkflowService instance
-     * @throws Error if no service is registered
-     */
-    get() {
-        if (!this.service) {
-            throw new Error('WorkflowService is not registered. Call register() first.');
-        }
-        return this.service;
-    }
-    /**
-     * Check if a service is registered
-     */
-    isRegistered() {
-        return this.service !== null;
-    }
-    /**
-     * Reset the registry (primarily for testing)
-     */
-    reset() {
-        this.service = null;
-    }
-}
-// Convenience function to get the service
-export function getWorkflowService() {
-    return WorkflowServiceRegistry.getInstance().get();
-}
-// Convenience function to register the service
-export function registerWorkflowService(service) {
-    WorkflowServiceRegistry.getInstance().register(service);
-}
-//# sourceMappingURL=registry.js.map

package/dist/core/src/env/workflow/service/registry.test.d.ts

@@ -1,5 +0,0 @@
-/**
- * Registry Tests
- */
-export {};
-//# sourceMappingURL=registry.test.d.ts.map