@ai-setting/roy-agent-core 1.0.0

package/src/env/workflow/nodes/agent-node.test.ts

@@ -0,0 +1,371 @@
+/**
+ * @fileoverview AgentNode TDD Tests
+ * 
+ * 测试 AgentNode 类的功能：
+ * - 运行 agent 成功
+ * - Agent runner 错误处理
+ * - Prompt 模板解析
+ * - 传递前置节点上下文
+ * - 处理 agent 超时
+ * - 记录执行元数据
+ */
+
+import { AgentNode, AgentRunner, AgentConfig, AgentResult } from './agent-node';
+import { NodeDefinition, NodeExecutionContext } from '../types';
+
+// ============================================================================
+// Test Setup
+// ============================================================================
+
+/**
+ * 创建默认的 NodeDefinition
+ */
+function createDefaultDefinition(overrides: Partial<NodeDefinition> = {}): NodeDefinition {
+  return {
+    id: 'test-agent-node',
+    type: 'agent',
+    name: 'Test Agent',
+    config: {
+      agent_type: 'general',
+      prompt: 'Hello, {{input.name}}!',
+    },
+    depends_on: [],
+    ...overrides,
+  };
+}
+
+/**
+ * 创建默认的执行上下文
+ */
+function createDefaultContext(overrides: Partial<NodeExecutionContext> = {}): NodeExecutionContext {
+  return {
+    sessionId: 'test-session-123',
+    workdir: '/tmp',
+    nodeOutputs: {},
+    input: { name: 'World' },
+    ...overrides,
+  };
+}
+
+/**
+ * 创建 Mock AgentRunner
+ */
+function createMockRunner(): {
+  runner: AgentRunner;
+  runMock: jest.Mock;
+} {
+  const runMock = jest.fn();
+  const runner: AgentRunner = { 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 as any });
+      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
+      );
+    });
+  });
+});