@elizaos/core 1.5.4 → 1.5.5

package/src/__tests__/prompts.test.ts

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

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