@ai-setting/roy-agent-core 1.3.10 → 1.3.11

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

@@ -1,318 +0,0 @@
-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);
-  });
-});