@ai-setting/roy-agent-core 1.0.0

package/src/env/session/session-component.extract-recent-messages.test.ts

@@ -0,0 +1,209 @@
+/**
+ * @fileoverview SessionComponent extractRecentMessages Tests
+ * 
+ * Tests for the extractRecentMessages method
+ */
+
+import { describe, it, expect, beforeEach } from 'bun:test';
+import { SessionComponent } from './session-component';
+import { MemorySessionStore } from './storage/memory';
+import type { SessionMessage } from './types';
+
+describe('SessionComponent.extractRecentMessages', () => {
+  let component: SessionComponent;
+  let store: MemorySessionStore;
+
+  beforeEach(async () => {
+    // Create component with memory store
+    component = new SessionComponent();
+    store = new MemorySessionStore();
+    
+    // Inject mock dependencies
+    (component as any).store = store;
+    (component as any).hooksConfig = {};
+  });
+
+  // Helper to create test messages
+  function createMessage(
+    id: string,
+    role: 'user' | 'assistant',
+    content: string,
+    parts?: any[]
+  ): SessionMessage {
+    return {
+      id,
+      sessionID: 'test-session',
+      role,
+      content,
+      timestamp: Date.now(),
+      parts,
+      metadata: {},
+    };
+  }
+
+  describe('basic extraction', () => {
+    it('should extract 2 turns by default', async () => {
+      const messages: SessionMessage[] = [
+        createMessage('1', 'user', 'First question'),
+        createMessage('2', 'assistant', 'First answer'),
+        createMessage('3', 'user', 'Second question'),
+        createMessage('4', 'assistant', 'Second answer'),
+        createMessage('5', 'user', 'Third question'),
+        createMessage('6', 'assistant', 'Third answer'),
+      ];
+
+      // Access private method via any cast
+      const result = (component as any).extractRecentMessages(messages);
+
+      expect(result.length).toBe(4); // 2 turns = user + assistant pairs
+      expect(result[0]).toEqual({ role: 'user', content: 'Second question' });
+      expect(result[1]).toEqual({ role: 'assistant', content: 'Second answer' });
+      expect(result[2]).toEqual({ role: 'user', content: 'Third question' });
+      expect(result[3]).toEqual({ role: 'assistant', content: 'Third answer' });
+    });
+
+    it('should extract 1 turn when specified', async () => {
+      const messages: SessionMessage[] = [
+        createMessage('1', 'user', 'First question'),
+        createMessage('2', 'assistant', 'First answer'),
+        createMessage('3', 'user', 'Second question'),
+        createMessage('4', 'assistant', 'Second answer'),
+      ];
+
+      const result = (component as any).extractRecentMessages(messages, 1);
+
+      expect(result.length).toBe(2); // 1 turn = user + assistant
+      expect(result[0]).toEqual({ role: 'user', content: 'Second question' });
+      expect(result[1]).toEqual({ role: 'assistant', content: 'Second answer' });
+    });
+
+    it('should extract 3 turns when specified', async () => {
+      const messages: SessionMessage[] = [
+        createMessage('1', 'user', 'First question'),
+        createMessage('2', 'assistant', 'First answer'),
+        createMessage('3', 'user', 'Second question'),
+        createMessage('4', 'assistant', 'Second answer'),
+        createMessage('5', 'user', 'Third question'),
+        createMessage('6', 'assistant', 'Third answer'),
+      ];
+
+      const result = (component as any).extractRecentMessages(messages, 3);
+
+      expect(result.length).toBe(6); // 3 turns
+    });
+  });
+
+  describe('skip tool calls and results', () => {
+    it('should skip assistant messages with tool-call parts', async () => {
+      const messages: SessionMessage[] = [
+        createMessage('1', 'user', 'Run a command'),
+        createMessage('2', 'assistant', 'I will run the command', [
+          { type: 'tool-call', toolName: 'bash' }
+        ]),
+        createMessage('3', 'user', 'Second question'),
+        createMessage('4', 'assistant', 'Second answer'),
+      ];
+
+      const result = (component as any).extractRecentMessages(messages, 1);
+
+      // Should skip the tool-call message and find next user+assistant pair
+      expect(result.length).toBe(2);
+      expect(result[0]).toEqual({ role: 'user', content: 'Second question' });
+      expect(result[1]).toEqual({ role: 'assistant', content: 'Second answer' });
+    });
+
+    it('should skip assistant messages with tool-result parts', async () => {
+      const messages: SessionMessage[] = [
+        createMessage('1', 'user', 'Run a command'),
+        createMessage('2', 'assistant', 'Command completed', [
+          { type: 'tool-result', toolName: 'bash' }
+        ]),
+        createMessage('3', 'user', 'Second question'),
+        createMessage('4', 'assistant', 'Second answer'),
+      ];
+
+      const result = (component as any).extractRecentMessages(messages, 1);
+
+      expect(result.length).toBe(2);
+      expect(result[0]).toEqual({ role: 'user', content: 'Second question' });
+      expect(result[1]).toEqual({ role: 'assistant', content: 'Second answer' });
+    });
+
+    it('should include assistant messages without tool parts', async () => {
+      const messages: SessionMessage[] = [
+        createMessage('1', 'user', 'Hello'),
+        createMessage('2', 'assistant', 'Hi there!'), // No tool parts
+        createMessage('3', 'user', 'How are you?'),
+        createMessage('4', 'assistant', 'I am fine!'),
+      ];
+
+      const result = (component as any).extractRecentMessages(messages, 1);
+
+      expect(result.length).toBe(2);
+      expect(result[1]).toEqual({ role: 'assistant', content: 'I am fine!' });
+    });
+  });
+
+  describe('skip checkpoint messages', () => {
+    it('should skip checkpoint messages when extracting', async () => {
+      const messages: SessionMessage[] = [
+        createMessage('1', 'user', 'First question'),
+        createMessage('2', 'assistant', 'First answer'),
+        createMessage('3', 'user', '', undefined), // Will be checkpoint
+        createMessage('3', 'user', 'Second question'),
+        createMessage('4', 'assistant', 'Second answer'),
+      ];
+      // Mark checkpoint
+      messages[2].metadata = { isCheckpoint: true };
+
+      const result = (component as any).extractRecentMessages(messages, 1);
+
+      expect(result.length).toBe(2);
+      expect(result[0]).toEqual({ role: 'user', content: 'Second question' });
+    });
+  });
+
+  describe('edge cases', () => {
+    it('should return empty array if no valid turns found', async () => {
+      const messages: SessionMessage[] = [
+        createMessage('1', 'assistant', 'I started first', [
+          { type: 'tool-call', toolName: 'bash' }
+        ]),
+      ];
+
+      const result = (component as any).extractRecentMessages(messages, 1);
+
+      expect(result.length).toBe(0);
+    });
+
+    it('should handle empty messages array', async () => {
+      const messages: SessionMessage[] = [];
+
+      const result = (component as any).extractRecentMessages(messages);
+
+      expect(result.length).toBe(0);
+    });
+
+    it('should handle only user messages', async () => {
+      const messages: SessionMessage[] = [
+        createMessage('1', 'user', 'Hello'),
+      ];
+
+      const result = (component as any).extractRecentMessages(messages, 1);
+
+      expect(result.length).toBe(0);
+    });
+
+    it('should handle messages with only empty content', async () => {
+      const messages: SessionMessage[] = [
+        createMessage('1', 'user', ''),
+        createMessage('2', 'assistant', '  '),
+      ];
+
+      const result = (component as any).extractRecentMessages(messages, 1);
+
+      // Empty content is filtered out
+      expect(result.length).toBe(0);
+    });
+  });
+});

package/src/env/session/session-component.test.ts

@@ -0,0 +1,132 @@
+/**
+ * @fileoverview SessionComponent Custom ID Tests
+ * 
+ * Tests for SessionComponent.create() supporting custom session ID
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'bun:test';
+import { SessionComponent } from './session-component';
+import { MemorySessionStore } from './storage/memory';
+import type { CreateSessionOptions, Session } from './types';
+
+describe('SessionComponent.create with custom ID', () => {
+  let component: SessionComponent;
+  let store: MemorySessionStore;
+
+  beforeEach(async () => {
+    // Create component with memory store
+    component = new SessionComponent();
+    store = new MemorySessionStore();
+    
+    // Inject mock dependencies
+    (component as any).store = store;
+    (component as any).hooksConfig = {};
+  });
+
+  describe('custom session ID', () => {
+    it('should accept custom session ID in options', async () => {
+      const customId = 'workflow_test123';
+      
+      const options: CreateSessionOptions = {
+        id: customId,
+        title: 'Test Session',
+        metadata: { type: 'workflow', workflowName: 'test' },
+      };
+
+      const session = await component.create(options);
+      
+      expect(session.id).toBe(customId);
+      expect(session.title).toBe('Test Session');
+    });
+
+    it('should generate ID if not provided', async () => {
+      const options: CreateSessionOptions = {
+        title: 'Test Session',
+      };
+
+      const session = await component.create(options);
+      
+      expect(session.id).toBeTruthy();
+      expect(typeof session.id).toBe('string');
+    });
+
+    it('should preserve workflow-style session ID', async () => {
+      const timestamp = Date.now();
+      const sessionId = `workflow_${timestamp}_1_abc`;
+      
+      const options: CreateSessionOptions = {
+        id: sessionId,
+        title: 'Workflow Session',
+      };
+
+      const session = await component.create(options);
+      
+      expect(session.id).toBe(sessionId);
+      expect(session.id.startsWith('workflow_')).toBe(true);
+    });
+
+    it('should create workflow session with correct metadata', async () => {
+      const sessionId = 'workflow_test_workflow1';
+      
+      const options: CreateSessionOptions = {
+        id: sessionId,
+        title: 'Workflow: test-workflow',
+        metadata: {
+          type: 'workflow',
+          workflowName: 'test-workflow',
+          workflowId: 'wf-123',
+          status: 'running',
+        },
+      };
+
+      const session = await component.create(options);
+      
+      expect(session.id).toBe(sessionId);
+      expect((session.metadata as any).type).toBe('workflow');
+      expect((session.metadata as any).workflowName).toBe('test-workflow');
+      expect((session.metadata as any).status).toBe('running');
+    });
+
+    it('should allow custom ID with parent session', async () => {
+      // First create parent session
+      const parentSession = await component.create({
+        title: 'Parent Session',
+      });
+
+      // Create child session with custom ID
+      const childOptions: CreateSessionOptions = {
+        id: `workflow_child_${Date.now()}`,
+        title: 'Child Workflow',
+        parentID: parentSession.id,
+      };
+
+      const childSession = await component.create(childOptions);
+      
+      expect(childSession.parentID).toBe(parentSession.id);
+      expect(childSession.id.startsWith('workflow_child_')).toBe(true);
+    });
+  });
+
+  describe('duplicate ID handling', () => {
+    it('should throw error if custom ID already exists', async () => {
+      const customId = 'workflow_duplicate_test';
+      
+      // Create first session with custom ID
+      await component.create({
+        id: customId,
+        title: 'First Session',
+      });
+
+      // Try to create second session with same ID
+      try {
+        await component.create({
+          id: customId,
+          title: 'Second Session',
+        });
+        expect.fail('Should have thrown an error');
+      } catch (error: any) {
+        expect(error.message).toContain('already exists');
+      }
+    });
+  });
+});