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

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

@@ -0,0 +1,377 @@
+/**
+ * @fileoverview Workflow LLM History Tests
+ *
+ * TDD 测试：验证 workflow 节点之间 LLM history 共享功能
+ */
+import { describe, it, expect, beforeEach, vi } from 'bun:test';
+// Mock AgentComponent
+const createMockAgentComponent = () => ({
+    registerAgent: vi.fn(),
+    getAgent: vi.fn().mockReturnValue({ name: 'test-agent' }),
+    listAgents: vi.fn().mockReturnValue([{ name: 'test-agent' }]),
+    run: vi.fn().mockResolvedValue({
+        finalText: 'test response',
+        iterations: 1,
+        toolCalls: [],
+    }),
+});
+// Mock SessionComponent
+const createMockSessionComponent = () => ({
+    create: vi.fn().mockResolvedValue({ id: 'agent_session_123' }),
+    addMessage: vi.fn().mockResolvedValue('msg_123'),
+    getMessages: vi.fn().mockResolvedValue([]),
+});
+describe('Workflow LLM History', () => {
+    describe('AgentContext with workflowHistory', () => {
+        it('should accept workflowHistory in AgentContext', () => {
+            // 模拟 AgentContext 接口应该接受 workflowHistory 字段
+            const context = {
+                sessionId: 'test-session',
+                workflowHistory: [
+                    { role: 'user', content: 'Hello from previous node' },
+                    { role: 'assistant', content: 'Response from previous node' },
+                ],
+            };
+            expect(context.workflowHistory).toBeDefined();
+            expect(context.workflowHistory).toHaveLength(2);
+            expect(context.workflowHistory[0].role).toBe('user');
+            expect(context.workflowHistory[1].role).toBe('assistant');
+        });
+        it('should be optional in AgentContext', () => {
+            // workflowHistory 应该是可选的
+            const context = {
+                sessionId: 'test-session',
+            };
+            expect(context.workflowHistory).toBeUndefined();
+        });
+        it('should have correct WorkflowHistoryMessage structure', () => {
+            const message = {
+                role: 'user',
+                content: 'Test message',
+                toolCallId: 'call_123',
+                toolName: 'test-tool',
+                nodeId: 'node1',
+            };
+            expect(message.role).toBe('user');
+            expect(message.content).toBe('Test message');
+            expect(message.toolCallId).toBe('call_123');
+            expect(message.toolName).toBe('test-tool');
+            expect(message.nodeId).toBe('node1');
+        });
+    });
+    describe('AgentComponentAdapter workflowHistory handling', () => {
+        let mockAgentComponent;
+        let mockSessionComponent;
+        let AgentComponentAdapter;
+        beforeEach(async () => {
+            vi.clearAllMocks();
+            mockAgentComponent = createMockAgentComponent();
+            mockSessionComponent = createMockSessionComponent();
+            // 动态导入以避免循环依赖问题
+            const module = await import('./agent-component-adapter');
+            AgentComponentAdapter = module.AgentComponentAdapter;
+        });
+        it('should receive workflowHistory in context when provided via config', async () => {
+            const adapter = new AgentComponentAdapter(mockAgentComponent, {}, mockSessionComponent);
+            // 设置初始历史
+            const workflowHistory = [
+                { role: 'user', content: 'Message 1' },
+                { role: 'assistant', content: 'Response 1' },
+            ];
+            const config = {
+                type: 'test-agent',
+                prompt: 'Current task',
+                nodeId: 'node1',
+                runId: 'run1',
+                workflowSessionId: 'workflow_run_1',
+                workflowHistory, // 通过 config 传递 history
+            };
+            await adapter.run(config);
+            // 验证 AgentComponent.run 被调用
+            expect(mockAgentComponent.run).toHaveBeenCalled();
+            // 验证 workflowHistory 被传递（通过检查 mock 被调用时的参数）
+            const callArgs = mockAgentComponent.run.mock.calls[0];
+            // AgentComponent.run(agentName, query, context) - 第三个参数是 context
+            const context = callArgs[2];
+            expect(context).toBeDefined();
+        });
+        it('should accumulate messages after agent execution', async () => {
+            const adapter = new AgentComponentAdapter(mockAgentComponent, {}, mockSessionComponent);
+            // 模拟 agent 执行后产生的消息
+            mockAgentComponent.run.mockResolvedValue({
+                finalText: 'Agent response',
+                iterations: 1,
+                toolCalls: [],
+                messages: [
+                    { role: 'user', content: 'Task 1' },
+                    { role: 'assistant', content: 'Agent response' },
+                ],
+            });
+            const workflowHistory = [
+                { role: 'user', content: 'Previous task' },
+                { role: 'assistant', content: 'Previous response' },
+            ];
+            const config = {
+                type: 'test-agent',
+                prompt: 'Current task',
+                nodeId: 'node1',
+                runId: 'run1',
+                workflowHistory,
+            };
+            await adapter.run(config);
+            // 验证返回结果包含生成的消息
+            // 注意：这需要适配器从 agent 结果中提取消息并追加到 history
+            // 这个测试验证了消息应该被累积的概念
+            expect(mockAgentComponent.run).toHaveBeenCalled();
+        });
+    });
+    describe('WorkflowEngine workflowHistory integration', () => {
+        it('should maintain workflowHistory in ActiveRunState', () => {
+            // 验证 ActiveRunState 应该包含 workflowHistory 字段
+            // 这个测试描述了期望的设计
+            const mockRunState = {
+                runId: 'run_1',
+                workflowHistory: [],
+                nodeOutputs: new Map(),
+            };
+            expect(mockRunState.workflowHistory).toBeDefined();
+            expect(Array.isArray(mockRunState.workflowHistory)).toBe(true);
+        });
+        it('should add node messages to workflowHistory after execution', () => {
+            // 模拟节点执行完成后的消息
+            const workflowHistory = [];
+            const nodeResultMessages = [
+                { role: 'user', content: 'Node 1 task', nodeId: 'node1' },
+                { role: 'assistant', content: 'Node 1 response', nodeId: 'node1' },
+            ];
+            // 累积到 workflowHistory
+            workflowHistory.push(...nodeResultMessages);
+            expect(workflowHistory).toHaveLength(2);
+            expect(workflowHistory[0].nodeId).toBe('node1');
+        });
+        it('should pass accumulated history to next agent node', () => {
+            // 模拟两个连续 agent 节点之间的 history 传递
+            const historyAfterNode1 = [
+                { role: 'user', content: 'Node 1 task' },
+                { role: 'assistant', content: 'Node 1 response' },
+            ];
+            // Node 2 应该接收 Node 1 的历史
+            const node2Context = {
+                sessionId: 'workflow_run_1',
+                workflowHistory: historyAfterNode1,
+            };
+            expect(node2Context.workflowHistory).toHaveLength(2);
+            expect(node2Context.workflowHistory[0].content).toBe('Node 1 task');
+            expect(node2Context.workflowHistory[1].content).toBe('Node 1 response');
+        });
+    });
+    describe('Message transformation to LLM format', () => {
+        it('should transform workflow messages to LLM format', () => {
+            // Workflow 消息格式转换为 LLM 消息格式
+            const workflowMessage = {
+                role: 'user',
+                content: 'Test message',
+                nodeId: 'node1',
+            };
+            const llmMessage = {
+                role: 'user',
+                content: workflowMessage.content,
+            };
+            expect(llmMessage.role).toBe('user');
+            expect(llmMessage.content).toBe('Test message');
+        });
+        it('should handle tool messages in LLM format', () => {
+            const workflowToolMessage = {
+                role: 'tool',
+                content: '{"result": "tool output"}',
+                toolCallId: 'call_123',
+                toolName: 'test-tool',
+            };
+            // 转换为 LLM 格式
+            const llmMessage = {
+                role: 'tool',
+                content: workflowToolMessage.content,
+            };
+            expect(llmMessage.role).toBe('tool');
+        });
+        it('should preserve message order in history', () => {
+            const messages = [
+                { role: 'user', content: 'Message 1' },
+                { role: 'assistant', content: 'Message 2' },
+                { role: 'user', content: 'Message 3' },
+                { role: 'tool', content: 'Tool result', toolCallId: 'call_1' },
+                { role: 'assistant', content: 'Message 5' },
+            ];
+            // 验证顺序保持
+            expect(messages[0].role).toBe('user');
+            expect(messages[1].role).toBe('assistant');
+            expect(messages[2].role).toBe('user');
+            expect(messages[3].role).toBe('tool');
+            expect(messages[4].role).toBe('assistant');
+        });
+    });
+});
+describe('Workflow LLM History - Integration Scenario', () => {
+    it('should simulate full workflow with history accumulation', async () => {
+        // 模拟完整 workflow 执行场景：
+        // Node A (agent) -> Node B (agent) -> Node C (agent)
+        const workflowHistory = [];
+        // Node A 执行
+        const nodeAMessages = [
+            { role: 'user', content: 'Task for Node A', nodeId: 'nodeA' },
+            { role: 'assistant', content: 'Response from Node A', nodeId: 'nodeA' },
+        ];
+        workflowHistory.push(...nodeAMessages);
+        // Node B 执行（应该看到 Node A 的历史）
+        expect(workflowHistory).toHaveLength(2);
+        const nodeBContext = { workflowHistory };
+        expect(nodeBContext.workflowHistory).toHaveLength(2);
+        const nodeBMessages = [
+            { role: 'user', content: 'Task for Node B', nodeId: 'nodeB' },
+            { role: 'assistant', content: 'Response from Node B', nodeId: 'nodeB' },
+        ];
+        workflowHistory.push(...nodeBMessages);
+        // Node C 执行（应该看到 Node A 和 Node B 的历史）
+        expect(workflowHistory).toHaveLength(4);
+        const nodeCContext = { workflowHistory };
+        expect(nodeCContext.workflowHistory).toHaveLength(4);
+        expect(nodeCContext.workflowHistory[0].nodeId).toBe('nodeA');
+        expect(nodeCContext.workflowHistory[2].nodeId).toBe('nodeB');
+        const nodeCMessages = [
+            { role: 'user', content: 'Task for Node C', nodeId: 'nodeC' },
+            { role: 'assistant', content: 'Response from Node C', nodeId: 'nodeC' },
+        ];
+        workflowHistory.push(...nodeCMessages);
+        // 最终历史应该包含所有消息
+        expect(workflowHistory).toHaveLength(6);
+        expect(workflowHistory[5].nodeId).toBe('nodeC');
+    });
+    it('should pass workflowHistory through AgentNode execution', async () => {
+        // 模拟 AgentNode 接收 workflowHistory 并传递给 agentRunner
+        const mockRunner = {
+            run: vi.fn().mockResolvedValue({
+                output: 'agent output',
+                messages: [
+                    { role: 'user', content: 'prompt' },
+                    { role: 'assistant', content: 'agent output' },
+                ],
+            }),
+        };
+        // 模拟 AgentNode
+        const definition = {
+            id: 'agent-node-1',
+            type: 'agent',
+            config: {
+                agent_type: 'general',
+                prompt: 'Do something',
+            },
+        };
+        const context = {
+            runId: 'run_1',
+            sessionId: 'session_1',
+            workflowName: 'test-workflow',
+            nodeId: 'agent-node-1',
+            input: {},
+            previousOutputs: new Map(),
+            nodeOutputs: new Map(),
+            config: {},
+            debug: false,
+            eventBus: { publish: vi.fn() },
+            workflowHistory: [
+                { role: 'user', content: 'Previous task', nodeId: 'previous-node' },
+                { role: 'assistant', content: 'Previous response', nodeId: 'previous-node' },
+            ],
+        };
+        // 执行 AgentNode
+        const { AgentNode } = await import('./agent-node');
+        const node = new AgentNode(definition, mockRunner);
+        const result = await node.execute(context);
+        // 验证 runner 被调用时传入了 workflowHistory
+        expect(mockRunner.run).toHaveBeenCalled();
+        const callArgs = mockRunner.run.mock.calls[0][0];
+        expect(callArgs.workflowHistory).toBe(context.workflowHistory);
+        expect(callArgs.nodeId).toBe('agent-node-1');
+        // 验证返回结果包含生成的消息
+        expect(result.output).toBeDefined();
+        expect(result.output.workflowHistory).toBeDefined();
+        expect(result.output.workflowHistory).toHaveLength(2);
+    });
+    it('should convert workflow messages to LLM format in AgentComponent', () => {
+        // 模拟 AgentComponent 将 workflowHistory 转换为 LLM 消息格式
+        const workflowMessages = [
+            { role: 'user', content: 'Message 1', nodeId: 'node1' },
+            { role: 'assistant', content: 'Message 2', nodeId: 'node1' },
+            { role: 'tool', content: '{"result": "ok"}', toolCallId: 'call_1', toolName: 'test-tool', nodeId: 'node1' },
+            { role: 'assistant', content: 'Message 3', nodeId: 'node1' },
+        ];
+        // 转换为 ModelMessage 格式（模拟 AgentComponent 的转换逻辑）
+        const llmMessages = workflowMessages.map(msg => ({
+            role: msg.role,
+            content: msg.content,
+            ...(msg.toolCallId ? { toolCallId: msg.toolCallId } : {}),
+            ...(msg.toolName ? { toolName: msg.toolName } : {}),
+        }));
+        expect(llmMessages).toHaveLength(4);
+        expect(llmMessages[0].role).toBe('user');
+        expect(llmMessages[1].role).toBe('assistant');
+        expect(llmMessages[2].role).toBe('tool');
+        expect(llmMessages[2].toolCallId).toBe('call_1');
+        expect(llmMessages[3].role).toBe('assistant');
+    });
+    it('should accumulate workflow history from node outputs in WorkflowEngine', () => {
+        // 模拟 WorkflowEngine 的 node.completed 事件处理
+        const workflowHistory = [];
+        // 模拟 Node A 完成，输出包含 workflowHistory
+        const nodeAOutput = {
+            result: 'Node A result',
+            workflowHistory: [
+                { role: 'user', content: 'Task A' },
+                { role: 'assistant', content: 'Response A' },
+            ],
+        };
+        // 模拟事件处理逻辑
+        if (nodeAOutput && typeof nodeAOutput === 'object' && 'workflowHistory' in nodeAOutput) {
+            const messages = nodeAOutput.workflowHistory;
+            if (Array.isArray(messages)) {
+                workflowHistory.push(...messages);
+            }
+        }
+        expect(workflowHistory).toHaveLength(2);
+        // 模拟 Node B 完成，输出包含 workflowHistory
+        const nodeBOutput = {
+            result: 'Node B result',
+            workflowHistory: [
+                { role: 'user', content: 'Task B' },
+                { role: 'assistant', content: 'Response B' },
+            ],
+        };
+        // 模拟事件处理逻辑
+        if (nodeBOutput && typeof nodeBOutput === 'object' && 'workflowHistory' in nodeBOutput) {
+            const messages = nodeBOutput.workflowHistory;
+            if (Array.isArray(messages)) {
+                workflowHistory.push(...messages);
+            }
+        }
+        expect(workflowHistory).toHaveLength(4);
+        expect(workflowHistory[0].content).toBe('Task A');
+        expect(workflowHistory[2].content).toBe('Task B');
+    });
+    it('should skip workflowHistory accumulation for non-agent nodes', () => {
+        // 模拟非 agent 节点（如 tool 节点）完成
+        const workflowHistory = [];
+        // Tool 节点的输出不包含 workflowHistory
+        const toolNodeOutput = {
+            result: 'tool result',
+        };
+        // 模拟事件处理逻辑 - 不应该累积
+        if (toolNodeOutput && typeof toolNodeOutput === 'object' && 'workflowHistory' in toolNodeOutput) {
+            const messages = toolNodeOutput.workflowHistory;
+            if (Array.isArray(messages)) {
+                workflowHistory.push(...messages);
+            }
+        }
+        // workflowHistory 应该保持为空
+        expect(workflowHistory).toHaveLength(0);
+    });
+});
+//# sourceMappingURL=workflow-llm-history.test.js.map

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

@@ -0,0 +1,119 @@
+import type { Node, NodeDefinition, NodeExecutionContext, NodeExecutionResult } from '../types';
+/**
+ * WorkflowRunner interface for running sub-workflows
+ */
+export interface WorkflowRunner {
+    /**
+     * Run a workflow by name
+     * @param workflowName - Name of the workflow to run
+     * @param input - Optional input to pass to the workflow
+     * @returns Promise resolving to the workflow run result
+     */
+    run(workflowName: string, input?: any): Promise<WorkflowRunResult>;
+    /**
+     * Get the status of a workflow run
+     * @param runId - The run ID to check
+     * @returns Promise resolving to the run result or null if not found
+     */
+    getRun(runId: string): Promise<WorkflowRunResult | null>;
+}
+/**
+ * Result from a workflow run
+ */
+export interface WorkflowRunResult {
+    /** Unique run ID */
+    runId: string;
+    /** Final status of the run */
+    status: 'completed' | 'failed' | 'stopped';
+    /** Output from the workflow (if completed) */
+    output?: any;
+    /** Error message (if failed or stopped) */
+    error?: string;
+}
+/**
+ * WorkflowNode configuration
+ */
+export interface WorkflowNodeConfig {
+    /** Name of the workflow to invoke */
+    workflow_name: string;
+    /** Input to pass to the sub-workflow (supports template strings) */
+    input?: Record<string, unknown>;
+    /** Whether to wait for completion (default: true) */
+    wait_complete?: boolean;
+}
+/**
+ * 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 declare class WorkflowNode implements Node {
+    private workflowRunner;
+    readonly type = "workflow";
+    readonly id: string;
+    private readonly config;
+    constructor(definition: NodeDefinition, workflowRunner: WorkflowRunner);
+    execute(context: NodeExecutionContext): Promise<NodeExecutionResult>;
+    /**
+     * 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.
+     */
+    private convertToMap;
+    /**
+     * 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
+     */
+    private resolveInput;
+    /**
+     * Resolve a value that may contain template references.
+     */
+    private resolveValue;
+    /**
+     * Resolve template references in a single string.
+     * Supports format: {{nodeId.output.path}}
+     */
+    private resolveStringTemplate;
+    /**
+     * Resolve a dot-notation path from previous outputs.
+     * First segment is the node ID, rest is the path within that node's output.
+     */
+    private resolvePath;
+    /**
+     * 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
+     */
+    private extractFromWrapper;
+    /**
+     * 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
+     */
+    private stringifyValue;
+}
+//# sourceMappingURL=workflow-node.d.ts.map