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

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

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

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

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

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

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

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

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