@ai-setting/roy-agent-core 1.0.0

package/src/env/workflow/nodes/agent-component-adapter.test.ts

@@ -0,0 +1,318 @@
+import { describe, it, expect, beforeEach, vi } from 'bun:test';
+import { AgentComponentAdapter, type PendingAgentSession } from './agent-component-adapter';
+
+// Custom AskUserError for testing
+class AskUserError extends Error {
+  readonly type = 'ask-user';
+  constructor(
+    public readonly runId: string,
+    public readonly sessionId: string,
+    public readonly nodeId: string,
+    public readonly nodeType: string,
+    public readonly query: string
+  ) {
+    super(`Ask user: ${query}`);
+    this.name = 'AskUserError';
+  }
+}
+
+// Mock AgentComponent
+const mockAgentComponent = {
+  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 mockSessionComponent = {
+  create: vi.fn().mockResolvedValue({ id: 'agent_session_123' }),
+  addMessage: vi.fn().mockResolvedValue('msg_123'),
+  getMessages: vi.fn().mockResolvedValue([]),
+};
+
+describe('AgentComponentAdapter', () => {
+  let adapter: AgentComponentAdapter;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    // Reset mock to return successful result by default
+    mockAgentComponent.run.mockResolvedValue({
+      finalText: 'test response',
+      iterations: 1,
+      toolCalls: [],
+    });
+    adapter = new AgentComponentAdapter(
+      mockAgentComponent as any,
+      {},
+      mockSessionComponent as any
+    );
+  });
+
+  describe('run()', () => {
+    it('should create agent session when sessionComponent is available', async () => {
+      const config = {
+        type: 'test-agent',
+        prompt: 'test prompt',
+        nodeId: 'node1',
+        runId: 'run1',
+        workflowSessionId: 'workflow_run_1',
+      };
+
+      const result = await adapter.run(config as any);
+
+      expect(mockSessionComponent.create).toHaveBeenCalledWith(
+        expect.objectContaining({
+          title: expect.stringContaining('Agent Session'),
+          metadata: expect.objectContaining({
+            type: 'agent',
+            workflowRunId: 'run1',
+            workflowNodeId: 'node1',
+          }),
+        })
+      );
+      expect(result.output).toBe('test response');
+    });
+
+    it('should not create session when sessionComponent is not available', async () => {
+      const adapterWithoutSession = new AgentComponentAdapter(
+        mockAgentComponent as any,
+        {},
+        undefined
+      );
+
+      const config = {
+        type: 'test-agent',
+        prompt: 'test prompt',
+      };
+
+      await adapterWithoutSession.run(config as any);
+
+      expect(mockSessionComponent.create).not.toHaveBeenCalled();
+    });
+
+    it('should map workflow session to agent sessions', async () => {
+      const config = {
+        type: 'test-agent',
+        prompt: 'test prompt',
+        nodeId: 'node1',
+        runId: 'run1',
+        workflowSessionId: 'workflow_run_1',
+      };
+
+      await adapter.run(config as any);
+
+      // Should have mapping
+      const agentSessions = adapter.getAgentSessionsForWorkflowSession('workflow_run_1');
+      expect(agentSessions.length).toBeGreaterThan(0);
+    });
+
+    it('should throw AskUserError to interrupt workflow (pending session preserved)', async () => {
+      // Mock agent to throw AskUserError
+      mockAgentComponent.run.mockImplementation(() => {
+        throw new AskUserError('run1', 'workflow_run1', 'node1', 'agent', 'Need user input?');
+      });
+
+      const config = {
+        type: 'test-agent',
+        prompt: 'test prompt',
+        nodeId: 'node1',
+        runId: 'run1',
+        workflowSessionId: 'workflow_run_1',
+      };
+
+      // Should reject with AskUserError
+      try {
+        await adapter.run(config as any);
+        expect(true).toBe(false); // Should not reach here
+      } catch (e: any) {
+        expect(e.name).toBe('AskUserError');
+      }
+
+      // Pending session should be preserved (not cleared)
+      const sessions = adapter.getPendingSessionsForRun('run1');
+      expect(sessions.length).toBeGreaterThan(0);
+      expect(sessions[0].nodeId).toBe('node1');
+    });
+  });
+
+  describe('resumeAgent()', () => {
+    it('should add user response to session and resume', async () => {
+      const agentSessionId = 'agent_session_123';
+      const userResponse = 'User response text';
+      const config = {
+        type: 'test-agent',
+        prompt: 'test prompt',
+      };
+
+      await adapter.resumeAgent(agentSessionId, userResponse, config as any);
+
+      // Verify addMessage was called (mock is already reset in beforeEach, so it should be called)
+      // Note: In this test, we just verify no error is thrown
+      expect(mockAgentComponent.run).toHaveBeenCalled();
+    });
+
+    it('should add user response as a new message with resume metadata', async () => {
+      const agentSessionId = 'agent_session_123';
+      const userResponse = 'yes, continue';
+      const config = {
+        type: 'test-agent',
+        prompt: 'test prompt',
+      };
+
+      await adapter.resumeAgent(agentSessionId, userResponse, config as any);
+
+      // Verify addMessage was called with correct metadata
+      expect(mockSessionComponent.addMessage).toHaveBeenCalledWith(
+        agentSessionId,
+        expect.objectContaining({
+          role: 'user',
+          content: userResponse,
+          metadata: expect.objectContaining({
+            type: 'user_intent',
+            intent: 'workflow.resume',
+          }),
+        })
+      );
+    });
+
+    it('should pass userResponse to run() for resume context', async () => {
+      const agentSessionId = 'agent_session_123';
+      const userResponse = 'yes';
+      const config = {
+        type: 'test-agent',
+        prompt: 'test prompt',
+      };
+
+      await adapter.resumeAgent(agentSessionId, userResponse, config as any);
+
+      // Verify run was called with sessionId set to agentSessionId
+      // (userResponse is stored in session, agent will load it from there)
+      expect(mockAgentComponent.run).toHaveBeenCalledWith(
+        config.type,
+        config.prompt,
+        expect.objectContaining({
+          sessionId: agentSessionId,
+        })
+      );
+    });
+
+    it('should remove session from pending after resume', async () => {
+      // First add a pending session manually
+      adapter.pendingSessions.set('agent_session_456', {
+        agentSessionId: 'agent_session_456',
+        nodeId: 'node1',
+        runId: 'run1',
+        createdAt: Date.now(),
+      });
+
+      const userResponse = 'yes';
+      const config = {
+        type: 'test-agent',
+        prompt: 'test prompt',
+      };
+
+      await adapter.resumeAgent('agent_session_456', userResponse, config as any);
+
+      // Session should be removed from pending
+      expect(adapter.pendingSessions.has('agent_session_456')).toBe(false);
+    });
+  });
+
+  describe('getPendingSession()', () => {
+    it('should return pending session when agent throws AskUserError', async () => {
+      // Mock agent to throw AskUserError
+      mockAgentComponent.run.mockImplementation(() => {
+        throw new AskUserError('run1', 'workflow_run1', 'node1', 'agent', 'Need user input?');
+      });
+
+      const config = {
+        type: 'test-agent',
+        prompt: 'test prompt',
+        nodeId: 'node1',
+        runId: 'run1',
+        workflowSessionId: 'workflow_run_1',
+      };
+
+      try {
+        await adapter.run(config as any);
+      } catch (e) {
+        // Expected
+      }
+
+      const sessions = adapter.getPendingSessionsForRun('run1');
+      expect(sessions.length).toBe(1);
+
+      const pending = adapter.getPendingSession(sessions[0].agentSessionId);
+      expect(pending).toBeDefined();
+      expect(pending?.nodeId).toBe('node1');
+    });
+
+    it('should return undefined for non-existent session', () => {
+      const pending = adapter.getPendingSession('non-existent');
+      expect(pending).toBeUndefined();
+    });
+  });
+
+  describe('getCurrentAgentSessionId()', () => {
+    it('should return current agent session ID during execution', async () => {
+      const config = {
+        type: 'test-agent',
+        prompt: 'test prompt',
+        nodeId: 'node1',
+        runId: 'run1',
+        workflowSessionId: 'workflow_run_1',
+      };
+
+      await adapter.run(config as any);
+
+      // After successful completion, current session is cleared
+      // But we can verify the session was created during execution
+      const agentSessions = adapter.getAgentSessionsForWorkflowSession('workflow_run_1');
+      expect(agentSessions.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('setSessionComponent()', () => {
+    it('should allow setting session component after construction', async () => {
+      const adapterWithoutSession = new AgentComponentAdapter(
+        mockAgentComponent as any,
+        {},
+        undefined
+      );
+
+      adapterWithoutSession.setSessionComponent!(mockSessionComponent as any);
+
+      // Now adapter should be able to create sessions
+      const config = {
+        type: 'test-agent',
+        prompt: 'test prompt',
+        nodeId: 'node1',
+        runId: 'run1',
+      };
+
+      await adapterWithoutSession.run(config as any);
+      expect(mockSessionComponent.create).toHaveBeenCalled();
+    });
+  });
+});
+
+describe('PendingAgentSession type', () => {
+  it('should have correct structure', () => {
+    const session: PendingAgentSession = {
+      agentSessionId: 'agent_123',
+      nodeId: 'node_1',
+      runId: 'run_1',
+      createdAt: Date.now(),
+    };
+
+    expect(session.agentSessionId).toBe('agent_123');
+    expect(session.nodeId).toBe('node_1');
+    expect(session.runId).toBe('run_1');
+    expect(session.createdAt).toBeGreaterThan(0);
+  });
+});