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

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

@@ -1,296 +0,0 @@
-/**
- * @fileoverview AgentNode TDD Tests
- *
- * 测试 AgentNode 类的功能：
- * - 运行 agent 成功
- * - Agent runner 错误处理
- * - Prompt 模板解析
- * - 传递前置节点上下文
- * - 处理 agent 超时
- * - 记录执行元数据
- */
-import { AgentNode } from "./agent-node.js";
-// ============================================================================
-// Test Setup
-// ============================================================================
-/**
- * 创建默认的 NodeDefinition
- */
-function createDefaultDefinition(overrides = {}) {
-    return {
-        id: 'test-agent-node',
-        type: 'agent',
-        name: 'Test Agent',
-        config: {
-            agent_type: 'general',
-            prompt: 'Hello, {{input.name}}!',
-        },
-        depends_on: [],
-        ...overrides,
-    };
-}
-/**
- * 创建默认的执行上下文
- */
-function createDefaultContext(overrides = {}) {
-    return {
-        sessionId: 'test-session-123',
-        workdir: '/tmp',
-        nodeOutputs: {},
-        input: { name: 'World' },
-        ...overrides,
-    };
-}
-/**
- * 创建 Mock AgentRunner
- */
-function createMockRunner() {
-    const runMock = jest.fn();
-    const runner = { run: runMock };
-    return { runner, runMock };
-}
-// ============================================================================
-// Test Suite
-// ============================================================================
-describe('AgentNode', () => {
-    describe('constructor', () => {
-        it('should create AgentNode with correct type', () => {
-            const definition = createDefaultDefinition();
-            const { runner } = createMockRunner();
-            const node = new AgentNode(definition, runner);
-            expect(node.type).toBe('agent');
-            expect(node.id).toBe('test-agent-node');
-        });
-        it('should store definition and runner references', () => {
-            const definition = createDefaultDefinition();
-            const { runner } = createMockRunner();
-            const node = new AgentNode(definition, runner);
-            // 通过执行来验证 runner 是否正确
-            expect(node).toBeDefined();
-        });
-    });
-    describe('execute', () => {
-        it('should run agent successfully with default config', async () => {
-            const definition = createDefaultDefinition();
-            const context = createDefaultContext();
-            const { runner, runMock } = createMockRunner();
-            runMock.mockResolvedValue({
-                output: { result: 'agent completed' },
-                metadata: { tokens: 100, duration: 500 },
-            });
-            const node = new AgentNode(definition, runner);
-            const result = await node.execute(context);
-            expect(result.error).toBeUndefined();
-            expect(result.output).toEqual({
-                result: { result: 'agent completed' },
-                metadata: { tokens: 100, duration: 500 },
-            });
-        });
-        it('should pass correct AgentConfig to runner', async () => {
-            const definition = createDefaultDefinition({
-                config: {
-                    agent_type: 'explore',
-                    prompt: 'Explore {{input.topic}}',
-                    options: {
-                        model: 'gpt-4',
-                        timeout: 60000,
-                    },
-                },
-            });
-            const context = createDefaultContext({ input: { topic: 'AI' } });
-            const { runner, runMock } = createMockRunner();
-            runMock.mockResolvedValue({
-                output: { result: 'exploration complete' },
-            });
-            const node = new AgentNode(definition, runner);
-            await node.execute(context);
-            // AgentNode 现在调用 runner.run(config, resumeOptions?)
-            // 注意：allowedTools: ['ask_user'] 被添加以确保 ask_user 工具在 workflow agent 上下文中可用
-            // agentSessionId 在没有 sessionComponent 时为 undefined
-            expect(runMock).toHaveBeenCalledWith({
-                type: 'explore',
-                prompt: 'Explore AI',
-                options: {
-                    model: 'gpt-4',
-                    timeout: 60000,
-                    allowedTools: ['ask_user'], // ask_user 工具仅在 workflow agent 上下文中可用
-                },
-                workflowHistory: undefined,
-                nodeId: 'test-agent-node',
-                agentSessionId: undefined,
-            }, undefined);
-        });
-        it('should resolve prompt template with previous outputs (AgentResult format)', async () => {
-            const definition = createDefaultDefinition({
-                config: {
-                    agent_type: 'general',
-                    prompt: 'Based on {{nodes.fetch-data}}, analyze it',
-                },
-            });
-            // AgentNode 执行后，output 是 { result, metadata } 格式
-            const context = createDefaultContext({
-                previousOutputs: new Map([
-                    ['fetch-data', { result: 'fetched data content', metadata: { duration: 100 } }],
-                ]),
-            });
-            const { runner, runMock } = createMockRunner();
-            runMock.mockResolvedValue({
-                output: { result: 'analysis complete' },
-            });
-            const node = new AgentNode(definition, runner);
-            await node.execute(context);
-            // AgentNode 现在调用 runner.run(config, resumeOptions?)
-            expect(runMock).toHaveBeenCalledWith(expect.objectContaining({
-                prompt: 'Based on fetched data content, analyze it',
-            }), undefined);
-        });
-        it('should resolve prompt template with nested property access', async () => {
-            const definition = createDefaultDefinition({
-                config: {
-                    agent_type: 'general',
-                    prompt: 'The result is: {{nodes.step1.result}}',
-                },
-            });
-            const context = createDefaultContext({
-                previousOutputs: new Map([
-                    ['step1', { result: 'nested result', metadata: {} }],
-                ]),
-            });
-            const { runner, runMock } = createMockRunner();
-            runMock.mockResolvedValue({
-                output: { result: 'done' },
-            });
-            const node = new AgentNode(definition, runner);
-            await node.execute(context);
-            expect(runMock).toHaveBeenCalledWith(expect.objectContaining({
-                prompt: 'The result is: nested result',
-            }), undefined);
-        });
-        it('should handle agent runner error', async () => {
-            const definition = createDefaultDefinition();
-            const context = createDefaultContext();
-            const { runner, runMock } = createMockRunner();
-            runMock.mockRejectedValue(new Error('Agent runner failed'));
-            const node = new AgentNode(definition, runner);
-            const result = await node.execute(context);
-            expect(result.error).toBe('Agent runner failed');
-        });
-        it('should handle agent timeout', async () => {
-            const definition = createDefaultDefinition();
-            const context = createDefaultContext();
-            const { runner, runMock } = createMockRunner();
-            runMock.mockRejectedValue(new Error('Agent timeout after 30000ms'));
-            const node = new AgentNode(definition, runner);
-            const result = await node.execute(context);
-            expect(result.error).toContain('timeout');
-        });
-        it('should record execution duration', async () => {
-            const definition = createDefaultDefinition();
-            const context = createDefaultContext();
-            const { runner, runMock } = createMockRunner();
-            runMock.mockResolvedValue({
-                output: { result: 'done' },
-            });
-            const node = new AgentNode(definition, runner);
-            const result = await node.execute(context);
-            expect(result.duration).toBeDefined();
-            expect(typeof result.duration).toBe('number');
-            expect(result.duration).toBeGreaterThanOrEqual(0);
-        });
-        it('should include metadata from agent result', async () => {
-            const definition = createDefaultDefinition();
-            const context = createDefaultContext();
-            const { runner, runMock } = createMockRunner();
-            runMock.mockResolvedValue({
-                output: { answer: 42 },
-                metadata: {
-                    tokens: 150,
-                    duration: 300,
-                    model: 'gpt-3.5-turbo',
-                },
-            });
-            const node = new AgentNode(definition, runner);
-            const result = await node.execute(context);
-            expect(result.output).toEqual({
-                result: { answer: 42 },
-                metadata: {
-                    tokens: 150,
-                    duration: 300,
-                    model: 'gpt-3.5-turbo',
-                },
-            });
-        });
-        it('should handle runner returning output without metadata', async () => {
-            const definition = createDefaultDefinition();
-            const context = createDefaultContext();
-            const { runner, runMock } = createMockRunner();
-            runMock.mockResolvedValue({
-                output: { simple: 'result' },
-            });
-            const node = new AgentNode(definition, runner);
-            const result = await node.execute(context);
-            expect(result.error).toBeUndefined();
-            expect(result.output).toEqual({
-                result: { simple: 'result' },
-            });
-        });
-        it('should handle complex template with multiple variables', async () => {
-            const definition = createDefaultDefinition({
-                config: {
-                    agent_type: 'general',
-                    prompt: 'Task: {{input.task}}\nData: {{nodes.step1.output}}',
-                },
-            });
-            const context = createDefaultContext({
-                input: { task: 'analyze' },
-                previousOutputs: new Map([
-                    ['step1', { output: 'data from step1' }],
-                ]),
-            });
-            const { runner, runMock } = createMockRunner();
-            runMock.mockResolvedValue({
-                output: { result: 'analysis complete' },
-            });
-            const node = new AgentNode(definition, runner);
-            await node.execute(context);
-            // AgentNode 现在调用 runner.run(config, resumeOptions?)
-            expect(runMock).toHaveBeenCalledWith(expect.objectContaining({
-                prompt: 'Task: analyze\nData: data from step1',
-            }), undefined);
-        });
-    });
-    describe('error handling', () => {
-        it('should handle undefined config gracefully', async () => {
-            const definition = createDefaultDefinition({ config: undefined });
-            const context = createDefaultContext();
-            const { runner, runMock } = createMockRunner();
-            runMock.mockResolvedValue({
-                output: { result: 'ok' },
-            });
-            const node = new AgentNode(definition, runner);
-            const result = await node.execute(context);
-            // 应该使用空配置或默认值
-            expect(result.error).toBeUndefined();
-        });
-        it('should handle missing prompt in config', async () => {
-            const definition = createDefaultDefinition({
-                config: {
-                    agent_type: 'general',
-                    // prompt 缺失
-                },
-            });
-            const context = createDefaultContext();
-            const { runner, runMock } = createMockRunner();
-            runMock.mockResolvedValue({
-                output: { result: 'ok' },
-            });
-            const node = new AgentNode(definition, runner);
-            const result = await node.execute(context);
-            // AgentNode 现在调用 runner.run(config, resumeOptions?)
-            expect(runMock).toHaveBeenCalledWith(expect.objectContaining({
-                prompt: '', // 应该使用空字符串或默认值
-            }), undefined);
-        });
-    });
-});
-//# sourceMappingURL=agent-node.test.js.map

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

@@ -1,69 +0,0 @@
-/**
- * @fileoverview AskUserNode - Node for requesting user input
- *
- * This node is used for simple pause/resume scenarios where a workflow
- * needs user input without going through an Agent.
- */
-import type { Node, NodeExecutionResult } from '../types';
-import type { NodeDefinition } from '../types';
-import type { NodeInterruptEvent } from '../types/workflow-hil';
-/**
- * AskUserNode Configuration
- */
-export interface AskUserNodeConfig {
-    /** Question to ask the user */
-    query?: string;
-    /** Optional choices for the user */
-    options?: string[];
-    /** If true, user must explicitly confirm */
-    required_confirm?: boolean;
-}
-/**
- * AskUserNode - Standalone node for user input requests
- *
- * This node pauses the workflow and waits for user response.
- * Used for simple human-in-loop scenarios without an Agent.
- *
- * @example
- * ```yaml
- * nodes:
- *   - id: confirm_step
- *     type: ask_user
- *     config:
- *       query: "Do you want to proceed?"
- *       options:
- *         - "Yes"
- *         - "No"
- *         - "Cancel"
- * ```
- */
-export declare class AskUserNode implements Node {
-    readonly type = "ask_user";
-    readonly id: string;
-    private config;
-    /**
-     * Create a new AskUserNode
-     */
-    constructor(definition: NodeDefinition);
-    /**
-     * Execute the AskUserNode
-     *
-     * Publishes a node.interrupt event and throws AskUserError to pause workflow.
-     *
-     * @param context - Node execution context
-     * @throws AskUserError - Always throws to pause workflow
-     */
-    execute(context: {
-        runId: string;
-        sessionId: string;
-        eventBus: {
-            publish(event: NodeInterruptEvent): Promise<void>;
-        };
-        nodeOutputs: Map<string, unknown>;
-    }): Promise<NodeExecutionResult>;
-    /**
-     * Validate node configuration
-     */
-    validateConfig(_config: Record<string, unknown>): boolean;
-}
-//# sourceMappingURL=ask-user-node.d.ts.map

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

@@ -1,67 +0,0 @@
-/**
- * @fileoverview AskUserNode - Node for requesting user input
- *
- * This node is used for simple pause/resume scenarios where a workflow
- * needs user input without going through an Agent.
- */
-import { AskUserError, createNodeInterruptEvent } from "../types/workflow-hil.js";
-// ==================== AskUserNode Class ====================
-/**
- * AskUserNode - Standalone node for user input requests
- *
- * This node pauses the workflow and waits for user response.
- * Used for simple human-in-loop scenarios without an Agent.
- *
- * @example
- * ```yaml
- * nodes:
- *   - id: confirm_step
- *     type: ask_user
- *     config:
- *       query: "Do you want to proceed?"
- *       options:
- *         - "Yes"
- *         - "No"
- *         - "Cancel"
- * ```
- */
-export class AskUserNode {
-    type = 'ask_user';
-    id;
-    config;
-    /**
-     * Create a new AskUserNode
-     */
-    constructor(definition) {
-        this.id = definition.id;
-        this.config = definition.config || {};
-    }
-    /**
-     * Execute the AskUserNode
-     *
-     * Publishes a node.interrupt event and throws AskUserError to pause workflow.
-     *
-     * @param context - Node execution context
-     * @throws AskUserError - Always throws to pause workflow
-     */
-    async execute(context) {
-        const query = this.config.query || '确认继续吗？';
-        const options = this.config.options;
-        // Build query with options if provided
-        const fullQuery = options
-            ? `${query} (选项: ${options.join(', ')})`
-            : query;
-        // Publish node.interrupt event
-        await context.eventBus.publish(createNodeInterruptEvent(context.runId, this.id, this.type, fullQuery));
-        // Throw AskUserError to pause workflow
-        throw new AskUserError(context.runId, context.sessionId, this.id, this.type, query);
-    }
-    /**
-     * Validate node configuration
-     */
-    validateConfig(_config) {
-        // query is optional, has default value
-        return true;
-    }
-}
-//# sourceMappingURL=ask-user-node.js.map

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

@@ -1,48 +0,0 @@
-/**
- * @fileoverview ConditionNode - Workflow condition node
- *
- * Evaluates a condition and decides whether to proceed or skip.
- *
- * Input can contain template strings like {{nodeId.output.path}} that will be
- * resolved from previousOutputs.
- */
-import { Node, NodeDefinition, NodeExecutionContext, NodeExecutionResult } from '../types';
-/**
- * ConditionNode evaluates a condition and returns the result.
- *
- * The condition can be:
- * - A boolean value
- * - A template expression that evaluates to a boolean
- * - A template reference to a previous node's output
- *
- * Usage in workflow:
- * ```yaml
- * nodes:
- *   - id: check-tests-pass
- *     type: condition
- *     config:
- *       condition: "{{run-unit-tests.success}}"
- *     depends_on:
- *       - run-unit-tests
- * ```
- */
-export declare class ConditionNode implements Node {
-    private definition;
-    readonly type = "condition";
-    readonly id: string;
-    constructor(definition: NodeDefinition);
-    execute(context: NodeExecutionContext): Promise<NodeExecutionResult>;
-    /**
-     * Resolve condition value, handling template references.
-     */
-    private resolveCondition;
-    /**
-     * Resolve a template path to get a value from previous outputs or workflow input.
-     */
-    private resolveTemplate;
-    /**
-     * Evaluate a resolved condition value.
-     */
-    private evaluateCondition;
-}
-//# sourceMappingURL=condition-node.d.ts.map

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

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

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

@@ -1,7 +0,0 @@
-export { ToolNode } from './tool-node';
-export type { ToolRegistry, Tool } from './tool-node';
-export { SkillNode } from './skill-node';
-export type { SkillRegistry, Skill } from './skill-node';
-export { WorkflowNode } from './workflow-node';
-export type { WorkflowRunner, WorkflowRunResult } from './workflow-node';
-//# sourceMappingURL=index.d.ts.map

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

@@ -1,5 +0,0 @@
-// Node implementations
-export { ToolNode } from "./tool-node.js";
-export { SkillNode } from "./skill-node.js";
-export { WorkflowNode } from "./workflow-node.js";
-//# sourceMappingURL=index.js.map