@elizaos/core 1.5.4 → 1.5.5

package/src/__tests__/search.test.ts

@@ -1,15 +0,0 @@
-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

@@ -1,204 +0,0 @@
-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

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