@elizaos/core 1.5.1 → 1.5.2

package/src/__tests__/search.test.ts

@@ -0,0 +1,15 @@
+import { describe, it, expect } from 'bun:test';
+import { BM25 } from '../search';
+
+describe('BM25 search', () => {
+  it('indexes documents and finds matches', () => {
+    const docs = [
+      { text: 'hello world' },
+      { text: 'another document' },
+      { text: 'world of javascript' },
+    ];
+    const bm = new BM25(docs, { fieldBoosts: { text: 1 } });
+    const results = bm.search('world');
+    expect(results[0].index).toBe(0);
+  });
+});

package/src/__tests__/services-by-type.test.ts

@@ -0,0 +1,204 @@
+import { describe, it, expect, beforeEach } from 'bun:test';
+import { AgentRuntime } from '../runtime';
+import { ServiceType, UUID } from '../types';
+import { Service } from '../types/service';
+import { IAgentRuntime } from '../types/runtime';
+import { v4 as uuidv4 } from 'uuid';
+
+// Mock service classes for testing
+class MockWalletService1 extends Service {
+  static override readonly serviceType = ServiceType.WALLET;
+  readonly capabilityDescription = 'Mock wallet service 1';
+
+  constructor(runtime: IAgentRuntime) {
+    super(runtime);
+  }
+
+  static async start(runtime: IAgentRuntime): Promise<MockWalletService1> {
+    return new MockWalletService1(runtime);
+  }
+
+  async stop(): Promise<void> {
+    // Mock stop implementation
+  }
+}
+
+class MockWalletService2 extends Service {
+  static override readonly serviceType = ServiceType.WALLET;
+  readonly capabilityDescription = 'Mock wallet service 2';
+
+  constructor(runtime: IAgentRuntime) {
+    super(runtime);
+  }
+
+  static async start(runtime: IAgentRuntime): Promise<MockWalletService2> {
+    return new MockWalletService2(runtime);
+  }
+
+  async stop(): Promise<void> {
+    // Mock stop implementation
+  }
+}
+
+class MockPdfService extends Service {
+  static override readonly serviceType = ServiceType.PDF;
+  readonly capabilityDescription = 'Mock PDF service';
+
+  constructor(runtime: IAgentRuntime) {
+    super(runtime);
+  }
+
+  static async start(runtime: IAgentRuntime): Promise<MockPdfService> {
+    return new MockPdfService(runtime);
+  }
+
+  async stop(): Promise<void> {
+    // Mock stop implementation
+  }
+}
+
+describe('Service Type System', () => {
+  let runtime: AgentRuntime;
+
+  beforeEach(() => {
+    runtime = new AgentRuntime({
+      agentId: uuidv4() as UUID,
+      character: {
+        name: 'Test Agent',
+        username: 'test',
+        clients: [],
+      },
+    });
+  });
+
+  describe('Multiple services of same type', () => {
+    it('should allow registering multiple services of the same type', async () => {
+      // Register two wallet services
+      await runtime.registerService(MockWalletService1);
+      await runtime.registerService(MockWalletService2);
+
+      // Both should be registered
+      expect(runtime.hasService(ServiceType.WALLET)).toBe(true);
+
+      // Get all wallet services
+      const walletServices = runtime.getServicesByType(ServiceType.WALLET);
+      expect(walletServices).toHaveLength(2);
+
+      // Check that both service instances are different
+      expect(walletServices[0]).toBeInstanceOf(MockWalletService1);
+      expect(walletServices[1]).toBeInstanceOf(MockWalletService2);
+    });
+
+    it('should return first service when using getService', async () => {
+      // Register two wallet services
+      await runtime.registerService(MockWalletService1);
+      await runtime.registerService(MockWalletService2);
+
+      // getService should return the first registered service
+      const firstService = runtime.getService(ServiceType.WALLET);
+      expect(firstService).toBeInstanceOf(MockWalletService1);
+    });
+
+    it('should return empty array for non-existent service type', () => {
+      const services = runtime.getServicesByType('non-existent-type');
+      expect(services).toHaveLength(0);
+    });
+
+    it('should return null for non-existent service type with getService', () => {
+      const service = runtime.getService('non-existent-type');
+      expect(service).toBe(null);
+    });
+  });
+
+  describe('Mixed service types', () => {
+    it('should handle multiple service types correctly', async () => {
+      // Register services of different types
+      await runtime.registerService(MockWalletService1);
+      await runtime.registerService(MockWalletService2);
+      await runtime.registerService(MockPdfService);
+
+      // Check wallet services
+      const walletServices = runtime.getServicesByType(ServiceType.WALLET);
+      expect(walletServices).toHaveLength(2);
+
+      // Check PDF services
+      const pdfServices = runtime.getServicesByType(ServiceType.PDF);
+      expect(pdfServices).toHaveLength(1);
+      expect(pdfServices[0]).toBeInstanceOf(MockPdfService);
+
+      // Check non-existent service type
+      const videoServices = runtime.getServicesByType(ServiceType.VIDEO);
+      expect(videoServices).toHaveLength(0);
+    });
+
+    it('should return correct services with getAllServices', async () => {
+      await runtime.registerService(MockWalletService1);
+      await runtime.registerService(MockWalletService2);
+      await runtime.registerService(MockPdfService);
+
+      const allServices = runtime.getAllServices();
+
+      // Should have 2 service types
+      expect(allServices.size).toBe(2);
+
+      // Wallet type should have 2 services
+      expect(allServices.get(ServiceType.WALLET)).toHaveLength(2);
+
+      // PDF type should have 1 service
+      expect(allServices.get(ServiceType.PDF)).toHaveLength(1);
+    });
+  });
+
+  describe('Service type validation', () => {
+    it('should handle hasService correctly with multiple services', async () => {
+      expect(runtime.hasService(ServiceType.WALLET)).toBe(false);
+
+      await runtime.registerService(MockWalletService1);
+      expect(runtime.hasService(ServiceType.WALLET)).toBe(true);
+
+      await runtime.registerService(MockWalletService2);
+      expect(runtime.hasService(ServiceType.WALLET)).toBe(true);
+    });
+
+    it('should return correct service types with getRegisteredServiceTypes', async () => {
+      await runtime.registerService(MockWalletService1);
+      await runtime.registerService(MockPdfService);
+
+      const serviceTypes = runtime.getRegisteredServiceTypes();
+      expect(serviceTypes).toContain(ServiceType.WALLET);
+      expect(serviceTypes).toContain(ServiceType.PDF);
+      expect(serviceTypes).toHaveLength(2);
+    });
+  });
+
+  describe('Service lifecycle', () => {
+    it('should stop all services of all types', async () => {
+      await runtime.registerService(MockWalletService1);
+      await runtime.registerService(MockWalletService2);
+      await runtime.registerService(MockPdfService);
+
+      // Mock the stop methods to track calls
+      const stopCalls: string[] = [];
+
+      const walletServices = runtime.getServicesByType(ServiceType.WALLET);
+      const pdfServices = runtime.getServicesByType(ServiceType.PDF);
+
+      walletServices[0].stop = async () => {
+        stopCalls.push('wallet1');
+      };
+      walletServices[1].stop = async () => {
+        stopCalls.push('wallet2');
+      };
+      pdfServices[0].stop = async () => {
+        stopCalls.push('pdf');
+      };
+
+      await runtime.stop();
+
+      expect(stopCalls).toContain('wallet1');
+      expect(stopCalls).toContain('wallet2');
+      expect(stopCalls).toContain('pdf');
+      expect(stopCalls).toHaveLength(3);
+    });
+  });
+});

package/src/__tests__/services.test.ts

@@ -0,0 +1,136 @@
+import { describe, it, expect, mock } from 'bun:test';
+import { createService, defineService } from '../services';
+import { Service } from '../types';
+import type { IAgentRuntime } from '../types';
+
+describe('service builder', () => {
+  // Mock runtime
+  const mockRuntime = {} as IAgentRuntime;
+
+  it('createService builds custom class', async () => {
+    const Builder = createService('TEST')
+      .withDescription('d')
+      .withStart(
+        async () =>
+          new (class extends Service {
+            capabilityDescription = 'Test service';
+            async stop() {}
+          })()
+      )
+      .build();
+    const instance = await (Builder as any).start(mockRuntime);
+    expect(instance).toBeInstanceOf(Service);
+    await instance.stop();
+  });
+
+  it('defineService builds from definition', async () => {
+    const Def = defineService({
+      serviceType: 'DEF' as any,
+      description: 'desc',
+      start: async () =>
+        new (class extends Service {
+          capabilityDescription = 'Definition service';
+          async stop() {}
+        })(),
+    });
+    const instance = await (Def as any).start(mockRuntime);
+    expect(instance).toBeInstanceOf(Service);
+    await instance.stop();
+  });
+
+  it('should throw error when start function is not defined', async () => {
+    // This test covers lines 59-60 - error when startFn is not defined
+    const Builder = createService('NO_START').withDescription('Service without start').build();
+
+    await expect((Builder as any).start(mockRuntime)).rejects.toThrow(
+      'Start function not defined for service NO_START'
+    );
+  });
+
+  it('should call custom stop function when provided', async () => {
+    // This test covers lines 65-68 - custom stopFn execution
+    const stopFn = mock().mockResolvedValue(undefined);
+
+    const Builder = createService('WITH_STOP')
+      .withDescription('Service with custom stop')
+      .withStart(
+        async () =>
+          new (class extends Service {
+            capabilityDescription = 'Service with stop';
+            async stop() {}
+          })()
+      )
+      .withStop(stopFn)
+      .build();
+
+    await (Builder as any).start(mockRuntime);
+    const builtInstance = new Builder();
+    await builtInstance.stop();
+
+    expect(stopFn).toHaveBeenCalled();
+  });
+
+  it('should handle service without stop function', async () => {
+    // This test ensures the else branch (no stopFn) is covered
+    const Builder = createService('NO_STOP')
+      .withDescription('Service without custom stop')
+      .withStart(
+        async () =>
+          new (class extends Service {
+            capabilityDescription = 'Service without stop';
+            async stop() {}
+          })()
+      )
+      .build();
+
+    const builtInstance = new Builder();
+    // Should not throw when no stopFn is provided
+    await expect(builtInstance.stop()).resolves.toBeUndefined();
+  });
+
+  it('defineService should provide default stop function', async () => {
+    // This test covers the default stop function in defineService
+    const Def = defineService({
+      serviceType: 'DEF_NO_STOP' as any,
+      description: 'Definition without stop',
+      start: async () =>
+        new (class extends Service {
+          capabilityDescription = 'Definition without stop';
+          async stop() {}
+        })(),
+      // Note: no stop function provided
+    });
+
+    await (Def as any).start(mockRuntime);
+    const defInstance = new Def();
+    // Should not throw when using default stop
+    expect(defInstance.stop()).resolves.toBeUndefined();
+  });
+
+  it('should set all properties correctly with chaining', () => {
+    // Test the full builder chain
+    const description = 'Test service description';
+    const serviceType = 'CHAINED_SERVICE';
+
+    const builder = createService(serviceType);
+    const withDesc = builder.withDescription(description);
+
+    // Verify chaining returns the same instance
+    expect(withDesc).toBe(builder);
+
+    const startFn = async () =>
+      new (class extends Service {
+        capabilityDescription = 'Chained service';
+        async stop() {}
+      })();
+    const withStart = withDesc.withStart(startFn);
+    expect(withStart).toBe(builder);
+
+    const stopFn = async () => {};
+    const withStop = withStart.withStop(stopFn);
+    expect(withStop).toBe(builder);
+
+    const BuiltClass = withStop.build();
+    expect((BuiltClass as any).serviceType).toBe(serviceType);
+  });
+});