@elizaos/core 1.5.1 → 1.5.2

package/src/__tests__/uuid.test.ts

@@ -0,0 +1,94 @@
+import { beforeEach, describe, expect, it } from 'bun:test';
+import type { UUID } from '../types';
+import { stringToUuid } from '../utils';
+
+describe('UUID Module', () => {
+  // Helper function to generate test strings
+  const generateTestString = (): string => Math.random().toString(36).substring(7);
+
+  // Test data setup
+  let testString: string;
+  let testNumber: number;
+
+  beforeEach(() => {
+    testString = generateTestString();
+    testNumber = Math.floor(Math.random() * 1000);
+  });
+
+  describe('stringToUuid', () => {
+    it('should generate a valid UUID matching the standard format', () => {
+      const result = stringToUuid(testString) as UUID;
+      expect(result).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i);
+    });
+
+    it('should generate consistent UUIDs for identical inputs', () => {
+      const input = testString;
+      const uuid1 = stringToUuid(input) as UUID;
+      const uuid2 = stringToUuid(input) as UUID;
+      expect(uuid1).toBe(uuid2);
+    });
+
+    it('should generate unique UUIDs for different inputs', () => {
+      const input1 = testString;
+      const input2 = generateTestString();
+      const uuid1 = stringToUuid(input1) as UUID;
+      const uuid2 = stringToUuid(input2) as UUID;
+      expect(uuid1).not.toBe(uuid2);
+    });
+
+    describe('input handling', () => {
+      it('should convert number inputs to strings correctly', () => {
+        const numberUuid = stringToUuid(testNumber) as UUID;
+        const stringUuid = stringToUuid(testNumber.toString()) as UUID;
+        expect(numberUuid).toBe(stringUuid);
+      });
+
+      it('should throw TypeError for invalid input types', () => {
+        expect(() => stringToUuid(undefined as any)).toThrow(TypeError);
+        expect(() => stringToUuid(null as any)).toThrow(TypeError);
+        expect(() => stringToUuid({} as any)).toThrow(TypeError);
+      });
+
+      it('should handle empty string input', () => {
+        const result = stringToUuid('') as UUID;
+        expect(result).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i);
+      });
+
+      it('should handle Unicode characters and emojis consistently', () => {
+        const unicodeInput = 'Hello 世界! 🌍';
+        const result1 = stringToUuid(unicodeInput) as UUID;
+        const result2 = stringToUuid(unicodeInput) as UUID;
+        expect(result1).toBe(result2);
+        expect(result1).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i);
+      });
+    });
+
+    describe('UUID version and variant bits', () => {
+      it('should set correct version bits (version 5)', () => {
+        const uuid = stringToUuid(testString) as UUID;
+        const versionChar = uuid.split('-')[2][0];
+        expect(versionChar).toBe('0');
+      });
+
+      it('should set correct variant bits (RFC4122)', () => {
+        const uuid = stringToUuid(testString) as UUID;
+        const variantByte = Number.parseInt(uuid.split('-')[3].slice(0, 2), 16);
+        expect(variantByte >= 0x80 && variantByte <= 0xbf).toBe(true);
+      });
+    });
+
+    describe('encoding handling', () => {
+      it('should handle URL-unsafe characters', () => {
+        const urlUnsafeInput = 'test?query=value&param=123';
+        const result = stringToUuid(urlUnsafeInput) as UUID;
+        expect(result).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i);
+      });
+
+      it('should handle very long inputs', () => {
+        const longInput = 'a'.repeat(1000);
+        const result = stringToUuid(longInput) as UUID;
+        expect(result).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i);
+      });
+    });
+  });
+});

package/src/actions.ts

@@ -0,0 +1,122 @@
+import { names, uniqueNamesGenerator } from 'unique-names-generator';
+import type { Action, ActionExample } from './types';
+
+/**
+ * Composes a set of example conversations based on provided actions and a specified count.
+ * It randomly selects examples from the provided actions and formats them with generated names.
+ *
+ * @param actionsData - An array of `Action` objects from which to draw examples.
+ * @param count - The number of examples to generate.
+ * @returns A string containing formatted examples of conversations.
+ */
+export const composeActionExamples = (actionsData: Action[], count: number): string => {
+  // Handle edge cases
+  if (!actionsData.length || count <= 0) {
+    return '';
+  }
+
+  // Filter out actions without examples
+  const actionsWithExamples = actionsData.filter(
+    (action) => action.examples && Array.isArray(action.examples) && action.examples.length > 0
+  );
+
+  // If no actions have examples, return empty string
+  if (!actionsWithExamples.length) {
+    return '';
+  }
+
+  // Create a working copy of the examples
+  const examplesCopy: ActionExample[][][] = actionsWithExamples.map((action) => [
+    ...(action.examples || []),
+  ]);
+
+  const selectedExamples: ActionExample[][] = [];
+
+  // Keep track of actions that still have examples
+  let availableActionIndices = examplesCopy
+    .map((examples, index) => (examples.length > 0 ? index : -1))
+    .filter((index) => index !== -1);
+
+  // Select examples until we reach the count or run out of examples
+  while (selectedExamples.length < count && availableActionIndices.length > 0) {
+    // Randomly select an action
+    const randomIndex = Math.floor(Math.random() * availableActionIndices.length);
+    const actionIndex = availableActionIndices[randomIndex];
+    const examples = examplesCopy[actionIndex];
+
+    // Select a random example from this action
+    const exampleIndex = Math.floor(Math.random() * examples.length);
+    selectedExamples.push(examples.splice(exampleIndex, 1)[0]);
+
+    // Remove action if it has no more examples
+    if (examples.length === 0) {
+      availableActionIndices.splice(randomIndex, 1);
+    }
+  }
+
+  // Format the selected examples
+  return formatSelectedExamples(selectedExamples);
+};
+
+/**
+ * Formats selected example conversations with random names.
+ */
+const formatSelectedExamples = (examples: ActionExample[][]): string => {
+  const MAX_NAME_PLACEHOLDERS = 5;
+
+  return examples
+    .map((example) => {
+      // Generate random names for this example
+      const randomNames = Array.from({ length: MAX_NAME_PLACEHOLDERS }, () =>
+        uniqueNamesGenerator({ dictionaries: [names] })
+      );
+
+      // Format the conversation
+      const conversation = example
+        .map((message) => {
+          // Build the base message - only include the text, no action info
+          let messageText = `${message.name}: ${message.content.text}`;
+
+          // Replace name placeholders
+          for (let i = 0; i < randomNames.length; i++) {
+            messageText = messageText.replaceAll(`{{name${i + 1}}}`, randomNames[i]);
+          }
+
+          return messageText;
+        })
+        .join('\n');
+
+      return `\n${conversation}`;
+    })
+    .join('\n');
+};
+
+/**
+ * Formats the names of the provided actions into a comma-separated string.
+ * @param actions - An array of `Action` objects from which to extract names.
+ * @returns A comma-separated string of action names.
+ */
+export function formatActionNames(actions: Action[]): string {
+  if (!actions?.length) return '';
+
+  // Create a shuffled copy instead of mutating the original array
+  return [...actions]
+    .sort(() => Math.random() - 0.5)
+    .map((action) => action.name)
+    .join(', ');
+}
+
+/**
+ * Formats the provided actions into a detailed string listing each action's name and description.
+ * @param actions - An array of `Action` objects to format.
+ * @returns A detailed string of actions, including names and descriptions.
+ */
+export function formatActions(actions: Action[]): string {
+  if (!actions?.length) return '';
+
+  // Create a shuffled copy without mutating the original
+  return [...actions]
+    .sort(() => Math.random() - 0.5)
+    .map((action) => `- **${action.name}**: ${action.description || 'No description available'}`)
+    .join('\n');
+}