@elizaos/core 1.5.1 → 1.5.2

package/src/__tests__/buffer.test.ts

@@ -0,0 +1,337 @@
+import { describe, expect, it, beforeEach, afterEach } from 'bun:test';
+import {
+  BufferUtils,
+  fromHex,
+  fromString,
+  fromBytes,
+  toHex,
+  toString,
+  isBuffer,
+  alloc,
+  concat,
+  slice,
+  equals,
+  byteLength,
+  randomBytes,
+} from '../utils/buffer';
+
+describe('Buffer Abstraction', () => {
+  describe('fromHex and toHex', () => {
+    it('should convert hex string to buffer and back', () => {
+      const hex = '48656c6c6f20576f726c64';
+      const buffer = fromHex(hex);
+      const result = toHex(buffer);
+      expect(result).toBe(hex.toLowerCase());
+    });
+
+    it('should handle empty hex string', () => {
+      const buffer = fromHex('');
+      expect(buffer.length).toBe(0);
+      expect(toHex(buffer)).toBe('');
+    });
+
+    it('should handle hex with non-hex characters', () => {
+      const hex = '48-65-6c-6c-6f';
+      const buffer = fromHex(hex);
+      const cleanHex = '48656c6c6f';
+      expect(toHex(buffer)).toBe(cleanHex.toLowerCase());
+    });
+
+    it('should handle odd-length hex strings', () => {
+      const hex = '486';
+      const buffer = fromHex(hex);
+      expect(buffer.length).toBe(1);
+      expect(buffer[0]).toBe(0x48);
+    });
+  });
+
+  describe('fromString and toString', () => {
+    it('should convert UTF-8 string to buffer and back', () => {
+      const text = 'Hello World';
+      const buffer = fromString(text);
+      const result = toString(buffer);
+      expect(result).toBe(text);
+    });
+
+    it('should handle UTF-8 with special characters', () => {
+      const text = 'Hello 世界 🌍';
+      const buffer = fromString(text);
+      const result = toString(buffer);
+      expect(result).toBe(text);
+    });
+
+    it('should handle base64 encoding', () => {
+      const text = 'Hello World';
+      const buffer = fromString(text);
+      const base64 = toString(buffer, 'base64');
+      expect(base64).toBe('SGVsbG8gV29ybGQ=');
+
+      const decoded = fromString(base64, 'base64');
+      expect(toString(decoded)).toBe(text);
+    });
+
+    it('should handle hex encoding in toString', () => {
+      const text = 'Hello';
+      const buffer = fromString(text);
+      const hex = toString(buffer, 'hex');
+      expect(hex).toBe('48656c6c6f');
+    });
+
+    it('should handle empty string', () => {
+      const buffer = fromString('');
+      expect(buffer.length).toBe(0);
+      expect(toString(buffer)).toBe('');
+    });
+
+    it('should handle utf-8 and utf8 encoding aliases', () => {
+      const text = 'Test';
+      const buffer1 = fromString(text, 'utf8');
+      const buffer2 = fromString(text, 'utf-8');
+      expect(equals(buffer1, buffer2)).toBe(true);
+    });
+  });
+
+  describe('fromBytes', () => {
+    it('should create buffer from byte array', () => {
+      const bytes = [72, 101, 108, 108, 111]; // "Hello"
+      const buffer = fromBytes(bytes);
+      expect(toString(buffer)).toBe('Hello');
+    });
+
+    it('should create buffer from Uint8Array', () => {
+      const bytes = new Uint8Array([72, 101, 108, 108, 111]);
+      const buffer = fromBytes(bytes);
+      expect(toString(buffer)).toBe('Hello');
+    });
+
+    it('should handle empty array', () => {
+      const buffer = fromBytes([]);
+      expect(buffer.length).toBe(0);
+    });
+  });
+
+  describe('isBuffer', () => {
+    it('should identify buffer-like objects', () => {
+      const buffer = fromString('test');
+      expect(isBuffer(buffer)).toBe(true);
+    });
+
+    it('should identify Uint8Array', () => {
+      const arr = new Uint8Array([1, 2, 3]);
+      expect(isBuffer(arr)).toBe(true);
+    });
+
+    it('should identify ArrayBuffer', () => {
+      const buffer = new ArrayBuffer(8);
+      expect(isBuffer(buffer)).toBe(true);
+    });
+
+    it('should reject non-buffer objects', () => {
+      expect(isBuffer('string')).toBe(false);
+      expect(isBuffer(123)).toBe(false);
+      expect(isBuffer({})).toBe(false);
+      expect(isBuffer([])).toBe(false);
+      expect(isBuffer(null)).toBe(false);
+      expect(isBuffer(undefined)).toBe(false);
+    });
+  });
+
+  describe('alloc', () => {
+    it('should create zero-filled buffer of specified size', () => {
+      const buffer = alloc(10);
+      expect(buffer.length).toBe(10);
+
+      // Check all bytes are zero
+      for (let i = 0; i < buffer.length; i++) {
+        expect(buffer[i]).toBe(0);
+      }
+    });
+
+    it('should create empty buffer for size 0', () => {
+      const buffer = alloc(0);
+      expect(buffer.length).toBe(0);
+    });
+  });
+
+  describe('concat', () => {
+    it('should concatenate multiple buffers', () => {
+      const buf1 = fromString('Hello');
+      const buf2 = fromString(' ');
+      const buf3 = fromString('World');
+      const result = concat([buf1, buf2, buf3]);
+      expect(toString(result)).toBe('Hello World');
+    });
+
+    it('should handle single buffer', () => {
+      const buffer = fromString('Hello');
+      const result = concat([buffer]);
+      expect(toString(result)).toBe('Hello');
+    });
+
+    it('should handle empty array', () => {
+      const result = concat([]);
+      expect(result.length).toBe(0);
+    });
+
+    it('should handle mix of buffer types', () => {
+      const buf1 = fromString('A');
+      const buf2 = new Uint8Array([66]); // 'B'
+      const result = concat([buf1, buf2]);
+      expect(toString(result)).toBe('AB');
+    });
+  });
+
+  describe('slice', () => {
+    it('should slice buffer from start to end', () => {
+      const buffer = fromString('Hello World');
+      const sliced = slice(buffer, 0, 5);
+      expect(toString(sliced)).toBe('Hello');
+    });
+
+    it('should slice from start if no end provided', () => {
+      const buffer = fromString('Hello World');
+      const sliced = slice(buffer, 6);
+      expect(toString(sliced)).toBe('World');
+    });
+
+    it('should handle negative indices', () => {
+      const buffer = fromString('Hello World');
+      const sliced = slice(buffer, -5);
+      expect(toString(sliced)).toBe('World');
+    });
+
+    it('should return empty buffer for invalid range', () => {
+      const buffer = fromString('Hello');
+      const sliced = slice(buffer, 10, 15);
+      expect(sliced.length).toBe(0);
+    });
+  });
+
+  describe('equals', () => {
+    it('should return true for equal buffers', () => {
+      const buf1 = fromString('Hello');
+      const buf2 = fromString('Hello');
+      expect(equals(buf1, buf2)).toBe(true);
+    });
+
+    it('should return false for different buffers', () => {
+      const buf1 = fromString('Hello');
+      const buf2 = fromString('World');
+      expect(equals(buf1, buf2)).toBe(false);
+    });
+
+    it('should return false for different lengths', () => {
+      const buf1 = fromString('Hi');
+      const buf2 = fromString('Hello');
+      expect(equals(buf1, buf2)).toBe(false);
+    });
+
+    it('should handle empty buffers', () => {
+      const buf1 = alloc(0);
+      const buf2 = alloc(0);
+      expect(equals(buf1, buf2)).toBe(true);
+    });
+  });
+
+  describe('byteLength', () => {
+    it('should return correct byte length', () => {
+      const buffer = fromString('Hello');
+      expect(byteLength(buffer)).toBe(5);
+    });
+
+    it('should handle UTF-8 multi-byte characters', () => {
+      const buffer = fromString('世界');
+      expect(byteLength(buffer)).toBe(6); // Each character is 3 bytes
+    });
+
+    it('should return 0 for empty buffer', () => {
+      const buffer = alloc(0);
+      expect(byteLength(buffer)).toBe(0);
+    });
+  });
+
+  describe('randomBytes', () => {
+    it('should generate random bytes of specified length', () => {
+      const buffer = randomBytes(16);
+      expect(buffer.length).toBe(16);
+    });
+
+    it('should generate different values on each call', () => {
+      const buf1 = randomBytes(16);
+      const buf2 = randomBytes(16);
+
+      // It's extremely unlikely these will be equal
+      expect(equals(buf1, buf2)).toBe(false);
+    });
+
+    it('should handle zero length', () => {
+      const buffer = randomBytes(0);
+      expect(buffer.length).toBe(0);
+    });
+
+    it('should generate bytes in valid range', () => {
+      const buffer = randomBytes(100);
+      for (let i = 0; i < buffer.length; i++) {
+        expect(buffer[i]).toBeGreaterThanOrEqual(0);
+        expect(buffer[i]).toBeLessThanOrEqual(255);
+      }
+    });
+  });
+
+  describe('BufferUtils namespace', () => {
+    it('should expose all functions through namespace', () => {
+      expect(BufferUtils.fromHex).toBe(fromHex);
+      expect(BufferUtils.fromString).toBe(fromString);
+      expect(BufferUtils.fromBytes).toBe(fromBytes);
+      expect(BufferUtils.toHex).toBe(toHex);
+      expect(BufferUtils.toString).toBe(toString);
+      expect(BufferUtils.isBuffer).toBe(isBuffer);
+      expect(BufferUtils.alloc).toBe(alloc);
+      expect(BufferUtils.concat).toBe(concat);
+      expect(BufferUtils.slice).toBe(slice);
+      expect(BufferUtils.equals).toBe(equals);
+      expect(BufferUtils.byteLength).toBe(byteLength);
+      expect(BufferUtils.randomBytes).toBe(randomBytes);
+    });
+  });
+
+  describe('Cross-environment compatibility', () => {
+    let originalBuffer: any;
+    let originalCrypto: any;
+
+    beforeEach(() => {
+      // Store original globals
+      originalBuffer = (global as any).Buffer;
+      originalCrypto = (global as any).crypto;
+    });
+
+    afterEach(() => {
+      // Restore original globals
+      if (originalBuffer !== undefined) {
+        (global as any).Buffer = originalBuffer;
+      } else {
+        delete (global as any).Buffer;
+      }
+
+      if (originalCrypto !== undefined) {
+        (global as any).crypto = originalCrypto;
+      }
+    });
+
+    it('should work without native Buffer', () => {
+      // Temporarily remove Buffer
+      delete (global as any).Buffer;
+
+      // Force module re-evaluation would be needed here
+      // For now, just test that functions work
+      const buffer = fromString('Test without Buffer');
+      const hex = toHex(buffer);
+      const decoded = fromHex(hex);
+      expect(toString(decoded)).toBe('Test without Buffer');
+    });
+
+    it.skip('should use crypto.getRandomValues when available', () => {
+      // Skip: Node.js environment uses crypto.randomBytes, not getRandomValues
+    });
+  });
+});

package/src/__tests__/character-validation.test.ts

@@ -0,0 +1,309 @@
+import { describe, expect, test } from 'bun:test';
+import {
+  validateCharacter,
+  parseAndValidateCharacter,
+  isValidCharacter,
+} from '../schemas/character';
+import type { Character } from '../types/agent';
+
+describe('Character Schema Validation', () => {
+  const validCharacter: Character = {
+    name: 'Test Character',
+    bio: 'A test character for validation',
+    messageExamples: [],
+    postExamples: [],
+    topics: ['AI', 'Testing'],
+    adjectives: ['helpful', 'reliable'],
+    knowledge: [],
+    plugins: [],
+    settings: {},
+    style: {},
+  };
+
+  const minimalValidCharacter: Character = {
+    name: 'Minimal Character',
+    bio: 'Just the basics',
+  };
+
+  describe('validateCharacter', () => {
+    test('should validate a complete valid character', () => {
+      const result = validateCharacter(validCharacter);
+      expect(result.success).toBe(true);
+      expect(result.data).toEqual(validCharacter);
+      expect(result.error).toBeUndefined();
+    });
+
+    test('should validate a minimal valid character', () => {
+      const result = validateCharacter(minimalValidCharacter);
+      expect(result.success).toBe(true);
+      expect(result.data).toEqual(minimalValidCharacter);
+    });
+
+    test('should reject character without name', () => {
+      const invalidCharacter = { bio: 'No name character' };
+      const result = validateCharacter(invalidCharacter);
+      expect(result.success).toBe(false);
+      expect(result.error?.message).toContain('Character validation failed');
+      expect(result.error?.issues).toBeDefined();
+    });
+
+    test('should reject character with empty name', () => {
+      const invalidCharacter = { name: '', bio: 'Empty name' };
+      const result = validateCharacter(invalidCharacter);
+      expect(result.success).toBe(false);
+      expect(result.error?.message).toContain('Character validation failed');
+    });
+
+    test('should reject character without bio', () => {
+      const invalidCharacter = { name: 'No Bio Character' };
+      const result = validateCharacter(invalidCharacter);
+      expect(result.success).toBe(false);
+      expect(result.error?.message).toContain('Character validation failed');
+    });
+
+    test('should accept bio as string array', () => {
+      const characterWithArrayBio = {
+        name: 'Array Bio Character',
+        bio: ['First line', 'Second line', 'Third line'],
+      };
+      const result = validateCharacter(characterWithArrayBio);
+      expect(result.success).toBe(true);
+    });
+
+    test('should reject unknown properties in strict mode', () => {
+      const characterWithExtra = {
+        ...validCharacter,
+        unknownProperty: 'should be rejected',
+        anotherUnknown: 123,
+      };
+      const result = validateCharacter(characterWithExtra);
+      expect(result.success).toBe(false);
+      expect(result.error?.message).toContain('Unrecognized key');
+    });
+
+    test('should validate optional fields correctly', () => {
+      const characterWithOptionals = {
+        name: 'Optional Fields Character',
+        bio: 'Testing optional fields',
+        username: 'test_user',
+        system: 'Test system prompt',
+        messageExamples: [
+          [
+            {
+              name: 'user',
+              content: { text: 'Hello' },
+            },
+            {
+              name: 'assistant',
+              content: { text: 'Hi there!' },
+            },
+          ],
+        ],
+        postExamples: ['Example post 1', 'Example post 2'],
+        topics: ['AI', 'Testing', 'Validation'],
+        adjectives: ['helpful', 'reliable', 'intelligent'],
+        knowledge: [
+          'knowledge/file1.txt',
+          { path: 'knowledge/file2.txt', shared: true },
+          { directory: 'knowledge/shared', shared: true },
+        ],
+        plugins: ['plugin1', 'plugin2'],
+        settings: {
+          temperature: 0.7,
+          maxTokens: 1000,
+          debug: true,
+        },
+        secrets: {
+          apiKey: 'secret-key',
+          enabled: true,
+        },
+        style: {
+          all: ['casual', 'friendly'],
+          chat: ['responsive', 'helpful'],
+          post: ['engaging', 'informative'],
+        },
+      };
+      const result = validateCharacter(characterWithOptionals);
+      expect(result.success).toBe(true);
+    });
+
+    test('should validate UUID format for id field', () => {
+      const characterWithValidUuid = {
+        ...validCharacter,
+        id: '123e4567-e89b-12d3-a456-426614174000',
+      };
+      const result = validateCharacter(characterWithValidUuid);
+      expect(result.success).toBe(true);
+    });
+
+    test('should reject invalid UUID format for id field', () => {
+      const characterWithInvalidUuid = {
+        ...validCharacter,
+        id: 'invalid-uuid-format',
+      };
+      const result = validateCharacter(characterWithInvalidUuid);
+      expect(result.success).toBe(false);
+      expect(result.error?.message).toContain('Invalid UUID format');
+    });
+  });
+
+  describe('parseAndValidateCharacter', () => {
+    test('should parse and validate valid JSON character', () => {
+      const jsonString = JSON.stringify(validCharacter);
+      const result = parseAndValidateCharacter(jsonString);
+      expect(result.success).toBe(true);
+      expect(result.data).toEqual(validCharacter);
+    });
+
+    test('should handle malformed JSON', () => {
+      const malformedJson = '{ "name": "Test", "bio": "Test" '; // Missing closing brace
+      const result = parseAndValidateCharacter(malformedJson);
+      expect(result.success).toBe(false);
+      expect(result.error?.message).toContain('Invalid JSON');
+    });
+
+    test('should handle JSON with invalid character data', () => {
+      const invalidCharacterJson = JSON.stringify({ name: '', bio: 'Invalid' });
+      const result = parseAndValidateCharacter(invalidCharacterJson);
+      expect(result.success).toBe(false);
+      expect(result.error?.message).toContain('Character validation failed');
+    });
+
+    test('should handle empty JSON object', () => {
+      const emptyJson = '{}';
+      const result = parseAndValidateCharacter(emptyJson);
+      expect(result.success).toBe(false);
+      expect(result.error?.message).toContain('Character validation failed');
+    });
+  });
+
+  describe('isValidCharacter', () => {
+    test('should return true for valid character', () => {
+      expect(isValidCharacter(validCharacter)).toBe(true);
+    });
+
+    test('should return false for invalid character', () => {
+      const invalidCharacter = { name: '', bio: 'Invalid' };
+      expect(isValidCharacter(invalidCharacter)).toBe(false);
+    });
+
+    test('should return false for non-object input', () => {
+      expect(isValidCharacter('string')).toBe(false);
+      expect(isValidCharacter(null)).toBe(false);
+      expect(isValidCharacter(undefined)).toBe(false);
+      expect(isValidCharacter(123)).toBe(false);
+    });
+  });
+
+  describe('Complex validation scenarios', () => {
+    test('should validate character with complex knowledge array', () => {
+      const characterWithComplexKnowledge = {
+        name: 'Knowledge Character',
+        bio: 'Testing knowledge validation',
+        knowledge: [
+          'simple/path.txt',
+          { path: 'path/with/config.txt', shared: false },
+          { path: 'shared/path.txt', shared: true },
+          { directory: 'knowledge/dir' },
+          { directory: 'shared/dir', shared: true },
+        ],
+      };
+      const result = validateCharacter(characterWithComplexKnowledge);
+      expect(result.success).toBe(true);
+    });
+
+    test('should validate character with complex message examples', () => {
+      const characterWithComplexMessages = {
+        name: 'Message Character',
+        bio: 'Testing message validation',
+        messageExamples: [
+          [
+            {
+              name: 'user',
+              content: {
+                text: 'Hello, how are you?',
+                source: 'user',
+              },
+            },
+            {
+              name: 'assistant',
+              content: {
+                text: 'I am doing well, thank you!',
+                source: 'assistant',
+                attachments: [{ type: 'text', data: 'additional info' }],
+              },
+            },
+          ],
+          [
+            {
+              name: 'user',
+              content: { text: 'What is the weather like?' },
+            },
+            {
+              name: 'assistant',
+              content: {
+                text: 'I would need to check a weather service for current conditions.',
+                url: 'https://weather.example.com',
+              },
+            },
+          ],
+        ],
+      };
+      const result = validateCharacter(characterWithComplexMessages);
+      expect(result.success).toBe(true);
+    });
+
+    test('should validate character with flexible settings', () => {
+      const characterWithFlexibleSettings = {
+        name: 'Settings Character',
+        bio: 'Testing settings validation',
+        settings: {
+          temperature: 0.8,
+          maxTokens: 2000,
+          enableDebug: true,
+          model: 'gpt-4',
+          customConfig: {
+            nested: {
+              deeply: {
+                value: 'test',
+              },
+            },
+          },
+          arrayValue: [1, 2, 3],
+        },
+        secrets: {
+          apiKey: 'sk-test123',
+          secretNumber: 42,
+          isEnabled: true,
+        },
+      };
+      const result = validateCharacter(characterWithFlexibleSettings);
+      expect(result.success).toBe(true);
+    });
+  });
+
+  describe('Edge cases and error handling', () => {
+    test('should handle null and undefined inputs', () => {
+      expect(validateCharacter(null).success).toBe(false);
+      expect(validateCharacter(undefined).success).toBe(false);
+    });
+
+    test('should handle non-object inputs', () => {
+      expect(validateCharacter('string').success).toBe(false);
+      expect(validateCharacter(123).success).toBe(false);
+      expect(validateCharacter([]).success).toBe(false);
+    });
+
+    test('should provide detailed error information', () => {
+      const invalidCharacter = {
+        name: '', // Invalid: empty string
+        bio: 123, // Invalid: should be string or string[]
+        messageExamples: 'invalid', // Invalid: should be array
+      };
+      const result = validateCharacter(invalidCharacter);
+      expect(result.success).toBe(false);
+      expect(result.error?.issues).toBeDefined();
+      expect(result.error?.issues?.length).toBeGreaterThan(0);
+    });
+  });
+});