@elizaos/core 1.5.1 → 1.5.2

package/src/__tests__/prompts.test.ts

@@ -0,0 +1,159 @@
+import { describe, expect, it } from 'bun:test';
+import {
+  shouldRespondTemplate,
+  messageHandlerTemplate,
+  postCreationTemplate,
+  booleanFooter,
+  imageDescriptionTemplate,
+} from '../prompts';
+
+describe('Prompts', () => {
+  describe('Template Structure', () => {
+    it('shouldRespondTemplate should contain required placeholders and XML structure', () => {
+      expect(shouldRespondTemplate).toContain('{{agentName}}');
+      expect(shouldRespondTemplate).toContain('{{providers}}');
+      expect(shouldRespondTemplate).toContain('<response>');
+      expect(shouldRespondTemplate).toContain('</response>');
+      expect(shouldRespondTemplate).toContain('<name>');
+      expect(shouldRespondTemplate).toContain('<reasoning>');
+      expect(shouldRespondTemplate).toContain('<action>');
+      expect(shouldRespondTemplate).toMatch(/RESPOND \| IGNORE \| STOP/);
+    });
+
+    it('messageHandlerTemplate should contain required placeholders and structure', () => {
+      expect(messageHandlerTemplate).toContain('{{agentName}}');
+      expect(messageHandlerTemplate).toContain('{{providers}}');
+      expect(messageHandlerTemplate).toContain('<response>');
+      expect(messageHandlerTemplate).toContain('</response>');
+      expect(messageHandlerTemplate).toContain('<thought>');
+      expect(messageHandlerTemplate).toContain('<actions>');
+      expect(messageHandlerTemplate).toContain('<providers>');
+      expect(messageHandlerTemplate).toContain('<text>');
+
+      // Check for important action ordering rules
+      expect(messageHandlerTemplate).toContain('IMPORTANT ACTION ORDERING RULES');
+      expect(messageHandlerTemplate).toContain('Actions are executed in the ORDER you list them');
+
+      // Ensure code block formatting rules are explicitly included
+      expect(messageHandlerTemplate).toContain('IMPORTANT CODE BLOCK FORMATTING RULES');
+      expect(messageHandlerTemplate).toContain('fenced code blocks');
+      expect(messageHandlerTemplate).toContain('single backticks');
+
+      // Check for provider selection rules
+      expect(messageHandlerTemplate).toContain('IMPORTANT PROVIDER SELECTION RULES');
+      expect(messageHandlerTemplate).toContain('ATTACHMENTS');
+      expect(messageHandlerTemplate).toContain('ENTITIES');
+    });
+
+    it('postCreationTemplate should contain required placeholders and examples', () => {
+      expect(postCreationTemplate).toContain('{{agentName}}');
+      expect(postCreationTemplate).toContain('{{twitterUserName}}');
+      expect(postCreationTemplate).toContain('{{providers}}');
+      expect(postCreationTemplate).toContain('{{adjective}}');
+      expect(postCreationTemplate).toContain('{{topic}}');
+      expect(postCreationTemplate).toContain('<response>');
+      expect(postCreationTemplate).toContain('</response>');
+      expect(postCreationTemplate).toContain('<thought>');
+      expect(postCreationTemplate).toContain('<post>');
+      expect(postCreationTemplate).toContain('<imagePrompt>');
+
+      // Check for example outputs
+      expect(postCreationTemplate).toMatch(/Example task outputs:/);
+      expect(postCreationTemplate).toContain('A post about');
+    });
+
+    it('booleanFooter should be a simple instruction', () => {
+      expect(booleanFooter).toBe('Respond with only a YES or a NO.');
+      expect(booleanFooter).toMatch(/^Respond with only a YES or a NO\.$/);
+    });
+
+    it('imageDescriptionTemplate should contain proper XML structure', () => {
+      expect(imageDescriptionTemplate).toContain('<task>');
+      expect(imageDescriptionTemplate).toContain('<instructions>');
+      expect(imageDescriptionTemplate).toContain('<output>');
+      expect(imageDescriptionTemplate).toContain('<response>');
+      expect(imageDescriptionTemplate).toContain('</response>');
+      expect(imageDescriptionTemplate).toContain('<title>');
+      expect(imageDescriptionTemplate).toContain('<description>');
+      expect(imageDescriptionTemplate).toContain('<text>');
+
+      // Check for important instructions
+      expect(imageDescriptionTemplate).toContain('Analyze the provided image');
+      expect(imageDescriptionTemplate).toContain('Be objective and descriptive');
+    });
+  });
+
+  describe('Template Consistency', () => {
+    const templates = [
+      shouldRespondTemplate,
+      messageHandlerTemplate,
+      postCreationTemplate,
+      imageDescriptionTemplate,
+    ];
+
+    it('all templates should have consistent XML output format instructions', () => {
+      templates.forEach((template) => {
+        expect(template).toContain('Do NOT include any thinking, reasoning, or <think> sections');
+        expect(template).toContain(
+          'IMPORTANT: Your response must ONLY contain the <response></response> XML block'
+        );
+      });
+    });
+
+    it('all templates should use proper XML closing tags', () => {
+      templates.forEach((template) => {
+        // Extract only the XML response format sections (not instructions mentioning tags)
+        const responseBlocks = template.match(/<response>[\s\S]*?<\/response>/g) || [];
+
+        responseBlocks.forEach((block) => {
+          // Get all open tags within response blocks
+          const openTags = (block.match(/<[^/][^>]+>/g) || [])
+            .filter((tag) => !tag.includes('/>'))
+            .filter((tag) => !tag.includes('think')); // Exclude mentioned-but-not-present tags
+
+          const closeTags = block.match(/<\/[^>]+>/g) || [];
+
+          // For each unique open tag, there should be a corresponding close tag
+          openTags.forEach((openTag) => {
+            const tagName = openTag.match(/<([^\s>]+)/)?.[1];
+            if (tagName && !['br', 'hr', 'img', 'input', 'meta', 'link'].includes(tagName)) {
+              expect(closeTags.some((closeTag) => closeTag.includes(tagName))).toBe(true);
+            }
+          });
+        });
+
+        // Also check the main structural tags outside response blocks
+        const mainTags = ['task', 'providers', 'instructions', 'output', 'keys', 'actionNames'];
+        mainTags.forEach((tag) => {
+          if (template.includes(`<${tag}>`)) {
+            expect(template).toContain(`</${tag}>`);
+          }
+        });
+      });
+    });
+  });
+
+  describe('Template Placeholders', () => {
+    it('should use consistent placeholder format', () => {
+      const placeholderPattern = /\{\{[^}]+\}\}/g;
+
+      const shouldRespondPlaceholders = shouldRespondTemplate.match(placeholderPattern) || [];
+      const messageHandlerPlaceholders = messageHandlerTemplate.match(placeholderPattern) || [];
+      const postCreationPlaceholders = postCreationTemplate.match(placeholderPattern) || [];
+
+      // All placeholders should use double curly braces
+      [
+        ...shouldRespondPlaceholders,
+        ...messageHandlerPlaceholders,
+        ...postCreationPlaceholders,
+      ].forEach((placeholder) => {
+        expect(placeholder).toMatch(/^\{\{[^}]+\}\}$/);
+      });
+
+      // Common placeholders should be consistent across templates
+      expect(shouldRespondPlaceholders).toContain('{{agentName}}');
+      expect(messageHandlerPlaceholders).toContain('{{agentName}}');
+      expect(postCreationPlaceholders).toContain('{{agentName}}');
+    });
+  });
+});

package/src/__tests__/roles.test.ts

@@ -0,0 +1,331 @@
+import { describe, it, expect, beforeEach, afterEach } from 'bun:test';
+import { mock, spyOn } from 'bun:test';
+import { getUserServerRole, findWorldsForOwner } from '../roles';
+import { Role, type IAgentRuntime, type UUID, type World } from '../types';
+import * as entities from '../entities';
+import * as logger_module from '../logger';
+
+describe('roles utilities', () => {
+  let mockRuntime: IAgentRuntime;
+
+  beforeEach(() => {
+    mock.restore();
+
+    // Set up scoped mocks for this test
+    spyOn(entities, 'createUniqueUuid').mockImplementation(
+      (_runtime, serverId) => `unique-${serverId}` as UUID
+    );
+
+    // Mock logger if it doesn't have the methods
+    if (logger_module.logger) {
+      const methods = ['error', 'info', 'warn', 'debug'];
+      methods.forEach((method) => {
+        if (typeof logger_module.logger[method] === 'function') {
+          spyOn(logger_module.logger, method).mockImplementation(() => {});
+        } else {
+          logger_module.logger[method] = mock(() => {});
+        }
+      });
+    }
+
+    mockRuntime = {
+      agentId: 'agent-123' as UUID,
+      getWorld: mock(),
+      getAllWorlds: mock(),
+    } as unknown as IAgentRuntime;
+  });
+
+  afterEach(() => {
+    mock.restore();
+  });
+
+  describe('getUserServerRole', () => {
+    it('should return role from world metadata', async () => {
+      const mockWorld: World = {
+        id: 'world-123' as UUID,
+        name: 'Test World',
+        agentId: 'agent-123' as UUID,
+        serverId: 'server-123',
+        metadata: {
+          roles: {
+            ['user-123-456-789-abc-def012345678' as UUID]: Role.ADMIN,
+          },
+        },
+      };
+
+      (mockRuntime.getWorld as any).mockResolvedValue(mockWorld);
+
+      const role = await getUserServerRole(
+        mockRuntime,
+        'user-123-456-789-abc-def012345678',
+        'server-123'
+      );
+      expect(role).toBe(Role.ADMIN);
+    });
+
+    it('should return Role.NONE when world is null', async () => {
+      (mockRuntime.getWorld as any).mockResolvedValue(null);
+
+      const role = await getUserServerRole(mockRuntime, 'user-123', 'server-123');
+      expect(role).toBe(Role.NONE);
+    });
+
+    it('should return Role.NONE when world has no metadata', async () => {
+      const mockWorld: World = {
+        id: 'world-123' as UUID,
+        name: 'Test World',
+        agentId: 'agent-123' as UUID,
+        serverId: 'server-123',
+        metadata: {},
+      };
+
+      (mockRuntime.getWorld as any).mockResolvedValue(mockWorld);
+
+      const role = await getUserServerRole(mockRuntime, 'user-123', 'server-123');
+      expect(role).toBe(Role.NONE);
+    });
+
+    it('should return Role.NONE when world has no roles in metadata', async () => {
+      const mockWorld: World = {
+        id: 'world-123' as UUID,
+        name: 'Test World',
+        agentId: 'agent-123' as UUID,
+        serverId: 'server-123',
+        metadata: {
+          someOtherData: 'value',
+        },
+      };
+
+      (mockRuntime.getWorld as any).mockResolvedValue(mockWorld);
+
+      const role = await getUserServerRole(mockRuntime, 'user-123', 'server-123');
+      expect(role).toBe(Role.NONE);
+    });
+
+    it('should check original ID format when first check fails', async () => {
+      const mockWorld: World = {
+        id: 'world-123' as UUID,
+        name: 'Test World',
+        agentId: 'agent-123' as UUID,
+        serverId: 'server-123',
+        metadata: {
+          roles: {
+            ['user-456-789-abc-def-012345678901' as UUID]: Role.OWNER,
+          },
+        },
+      };
+
+      (mockRuntime.getWorld as any).mockResolvedValue(mockWorld);
+
+      // Even though the code has duplicate checks for entityId, it should return NONE
+      // since 'user-123' is not in the roles
+      const role = await getUserServerRole(mockRuntime, 'user-123', 'server-123');
+      expect(role).toBe(Role.NONE);
+    });
+
+    it('should return role for different role types', async () => {
+      const mockWorld: World = {
+        id: 'world-123' as UUID,
+        name: 'Test World',
+        agentId: 'agent-123' as UUID,
+        serverId: 'server-123',
+        metadata: {
+          roles: {
+            ['owner-user-123-456-789-abcdef0123' as UUID]: Role.OWNER,
+            ['admin-user-123-456-789-abcdef0123' as UUID]: Role.ADMIN,
+            ['none-user-123-456-789-abcdef01234' as UUID]: Role.NONE,
+          },
+        },
+      };
+
+      (mockRuntime.getWorld as any).mockResolvedValue(mockWorld);
+
+      const ownerRole = await getUserServerRole(
+        mockRuntime,
+        'owner-user-123-456-789-abcdef0123',
+        'server-123'
+      );
+      expect(ownerRole).toBe(Role.OWNER);
+
+      const adminRole = await getUserServerRole(
+        mockRuntime,
+        'admin-user-123-456-789-abcdef0123',
+        'server-123'
+      );
+      expect(adminRole).toBe(Role.ADMIN);
+
+      const noneRole = await getUserServerRole(
+        mockRuntime,
+        'none-user-123-456-789-abcdef01234',
+        'server-123'
+      );
+      expect(noneRole).toBe(Role.NONE);
+    });
+  });
+
+  describe('findWorldsForOwner', () => {
+    it('should find worlds where user is owner', async () => {
+      const mockWorlds: World[] = [
+        {
+          id: 'world-1' as UUID,
+          name: 'World 1',
+          agentId: 'agent-123' as UUID,
+          serverId: 'server-1',
+          metadata: {
+            ownership: {
+              ownerId: 'user-123',
+            },
+          },
+        },
+        {
+          id: 'world-2' as UUID,
+          name: 'World 2',
+          agentId: 'agent-123' as UUID,
+          serverId: 'server-2',
+          metadata: {
+            ownership: {
+              ownerId: 'other-user',
+            },
+          },
+        },
+        {
+          id: 'world-3' as UUID,
+          name: 'World 3',
+          agentId: 'agent-123' as UUID,
+          serverId: 'server-3',
+          metadata: {
+            ownership: {
+              ownerId: 'user-123',
+            },
+          },
+        },
+      ];
+
+      (mockRuntime.getAllWorlds as any).mockResolvedValue(mockWorlds);
+
+      const ownerWorlds = await findWorldsForOwner(mockRuntime, 'user-123');
+
+      expect(ownerWorlds).toBeDefined();
+      expect(ownerWorlds?.length).toBe(2);
+      expect(ownerWorlds?.[0].id).toBe('world-1' as UUID);
+      expect(ownerWorlds?.[1].id).toBe('world-3' as UUID);
+    });
+
+    it('should return null when entityId is empty', async () => {
+      const { logger } = await import('../logger');
+
+      const result = await findWorldsForOwner(mockRuntime, '');
+
+      expect(result).toBeNull();
+      expect(logger.error).toHaveBeenCalledWith('User ID is required to find server');
+    });
+
+    it('should return null when entityId is null', async () => {
+      const { logger } = await import('../logger');
+
+      const result = await findWorldsForOwner(mockRuntime, null as any);
+
+      expect(result).toBeNull();
+      expect(logger.error).toHaveBeenCalledWith('User ID is required to find server');
+    });
+
+    it('should return null when no worlds exist', async () => {
+      const { logger } = await import('../logger');
+
+      (mockRuntime.getAllWorlds as any).mockResolvedValue([]);
+
+      const result = await findWorldsForOwner(mockRuntime, 'user-123');
+
+      expect(result).toBeNull();
+      expect(logger.info).toHaveBeenCalledWith('No worlds found for this agent');
+    });
+
+    it('should return null when getAllWorlds returns null', async () => {
+      const { logger } = await import('../logger');
+
+      (mockRuntime.getAllWorlds as any).mockResolvedValue(null);
+
+      const result = await findWorldsForOwner(mockRuntime, 'user-123');
+
+      expect(result).toBeNull();
+      expect(logger.info).toHaveBeenCalledWith('No worlds found for this agent');
+    });
+
+    it('should return null when no worlds match the owner', async () => {
+      const mockWorlds: World[] = [
+        {
+          id: 'world-1' as UUID,
+          name: 'World 1',
+          agentId: 'agent-123' as UUID,
+          serverId: 'server-1',
+          metadata: {
+            ownership: {
+              ownerId: 'other-user-1',
+            },
+          },
+        },
+        {
+          id: 'world-2' as UUID,
+          name: 'World 2',
+          agentId: 'agent-123' as UUID,
+          serverId: 'server-2',
+          metadata: {
+            ownership: {
+              ownerId: 'other-user-2',
+            },
+          },
+        },
+      ];
+
+      (mockRuntime.getAllWorlds as any).mockResolvedValue(mockWorlds);
+
+      const result = await findWorldsForOwner(mockRuntime, 'user-123');
+
+      expect(result).toBeNull();
+    });
+
+    it('should handle worlds without metadata', async () => {
+      const mockWorlds: World[] = [
+        {
+          id: 'world-1' as UUID,
+          name: 'World 1',
+          agentId: 'agent-123' as UUID,
+          serverId: 'server-1',
+          metadata: {},
+        },
+        {
+          id: 'world-2' as UUID,
+          name: 'World 2',
+          agentId: 'agent-123' as UUID,
+          serverId: 'server-2',
+        } as World,
+      ];
+
+      (mockRuntime.getAllWorlds as any).mockResolvedValue(mockWorlds);
+
+      const result = await findWorldsForOwner(mockRuntime, 'user-123');
+
+      expect(result).toBeNull();
+    });
+
+    it('should handle worlds without ownership in metadata', async () => {
+      const mockWorlds: World[] = [
+        {
+          id: 'world-1' as UUID,
+          name: 'World 1',
+          agentId: 'agent-123' as UUID,
+          serverId: 'server-1',
+          metadata: {
+            someOtherData: 'value',
+          },
+        },
+      ];
+
+      (mockRuntime.getAllWorlds as any).mockResolvedValue(mockWorlds);
+
+      const result = await findWorldsForOwner(mockRuntime, 'user-123');
+
+      expect(result).toBeNull();
+    });
+  });
+});