@elizaos/test-utils 1.4.5 → 1.5.0

package/dist/index.js

@@ -3,7 +3,7 @@ import { AgentRuntime, logger as logger3, stringToUuid } from "@elizaos/core";
 
 // ../../node_modules/uuid/dist/esm/stringify.js
 var byteToHex = [];
-for (let i = 0; i < 256; ++i) {
+for (let i = 0;i < 256; ++i) {
   byteToHex.push((i + 256).toString(16).slice(1));
 }
 function unsafeStringify(arr, offset = 0) {
@@ -43,7 +43,7 @@ function v4(options, buf, offset) {
     if (offset < 0 || offset + 16 > buf.length) {
       throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);
     }
-    for (let i = 0; i < 16; ++i) {
+    for (let i = 0;i < 16; ++i) {
       buf[offset + i] = rnds[i];
     }
     return buf;
@@ -51,16 +51,11 @@ function v4(options, buf, offset) {
   return unsafeStringify(rnds);
 }
 var v4_default = v4;
-
 // src/testDatabase.ts
 import { logger } from "@elizaos/core";
-var TestDatabaseManager = class {
-  testDatabases = /* @__PURE__ */ new Map();
-  tempPaths = /* @__PURE__ */ new Set();
-  /**
-   * Creates an isolated database for testing
-   * Uses PostgreSQL for testing when available, falls back to mock database
-   */
+class TestDatabaseManager {
+  testDatabases = new Map;
+  tempPaths = new Set;
   async createIsolatedDatabase(testId) {
     try {
       logger.debug(`Creating isolated test database for ${testId}`);
@@ -80,24 +75,17 @@ var TestDatabaseManager = class {
             if (!postgresUrl) {
               throw new Error("PostgreSQL URL not available - falling back to mock database");
             }
-            adapter = await sqlPlugin.createDatabaseAdapter(
-              {
-                postgresUrl
-              },
-              "11111111-2222-3333-4444-555555555555"
-            );
+            adapter = await sqlPlugin.createDatabaseAdapter({
+              postgresUrl
+            }, "11111111-2222-3333-4444-555555555555");
             logger.debug(`Successfully created PostgreSQL adapter for ${testId}`);
           } catch (importError) {
-            logger.warn(
-              `SQL plugin not available: ${importError instanceof Error ? importError.message : String(importError)} - falling back to mock database`
-            );
+            logger.warn(`SQL plugin not available: ${importError instanceof Error ? importError.message : String(importError)} - falling back to mock database`);
             adapter = this.createMockDatabase(testId);
           }
         }
       } catch (postgresError) {
-        logger.warn(
-          `Failed to create PostgreSQL database: ${postgresError instanceof Error ? postgresError.message : String(postgresError)} - falling back to mock database`
-        );
+        logger.warn(`Failed to create PostgreSQL database: ${postgresError instanceof Error ? postgresError.message : String(postgresError)} - falling back to mock database`);
         adapter = this.createMockDatabase(testId);
       }
       await adapter.init();
@@ -105,42 +93,32 @@ var TestDatabaseManager = class {
       logger.debug(`Successfully created isolated database for ${testId}`);
       return adapter;
     } catch (error) {
-      logger.error(
-        `Failed to create test database for ${testId}: ${error instanceof Error ? error.message : String(error)}`
-      );
-      throw new Error(
-        `Test database creation failed: ${error instanceof Error ? error.message : String(error)}`
-      );
+      logger.error(`Failed to create test database for ${testId}: ${error instanceof Error ? error.message : String(error)}`);
+      throw new Error(`Test database creation failed: ${error instanceof Error ? error.message : String(error)}`);
     }
   }
-  /**
-   * Creates a minimal mock database adapter for testing when real database unavailable
-   * This is a FUNCTIONAL mock that actually stores data in memory
-   */
   createMockDatabase(testId) {
     const storage = {
-      agents: /* @__PURE__ */ new Map(),
-      entities: /* @__PURE__ */ new Map(),
-      memories: /* @__PURE__ */ new Map(),
-      relationships: /* @__PURE__ */ new Map(),
-      rooms: /* @__PURE__ */ new Map(),
-      participants: /* @__PURE__ */ new Map(),
-      cache: /* @__PURE__ */ new Map(),
-      worlds: /* @__PURE__ */ new Map(),
-      tasks: /* @__PURE__ */ new Map(),
-      logs: /* @__PURE__ */ new Map()
+      agents: new Map,
+      entities: new Map,
+      memories: new Map,
+      relationships: new Map,
+      rooms: new Map,
+      participants: new Map,
+      cache: new Map,
+      worlds: new Map,
+      tasks: new Map,
+      logs: new Map
     };
     const adapter = {
       db: null,
-      // Mock database instance
       async initialize() {
         logger.debug(`Initialized mock database for ${testId}`);
       },
       async init() {
         logger.debug(`Initialized mock database for ${testId}`);
       },
-      async runMigrations() {
-      },
+      async runMigrations() {},
       async isReady() {
         return true;
       },
@@ -158,8 +136,7 @@ var TestDatabaseManager = class {
       async getConnection() {
         return null;
       },
-      async ensureEmbeddingDimension() {
-      },
+      async ensureEmbeddingDimension() {},
       async getAgent(agentId) {
         return storage.agents.get(agentId) || null;
       },
@@ -182,7 +159,6 @@ var TestDatabaseManager = class {
       async deleteAgent(agentId) {
         return storage.agents.delete(agentId);
       },
-      // Entity operations
       async createEntity(entity) {
         const id = entity.id || v4_default();
         const fullEntity = { ...entity, id };
@@ -207,9 +183,7 @@ var TestDatabaseManager = class {
         storage.entities.set(entity.id, entity);
       },
       async getEntitiesForRoom(roomId) {
-        const participants = Array.from(storage.participants.values()).filter(
-          (p) => p.roomId === roomId
-        );
+        const participants = Array.from(storage.participants.values()).filter((p) => p.roomId === roomId);
         const entities = [];
         for (const participant of participants) {
           const entity = storage.entities.get(participant.entityId);
@@ -219,7 +193,6 @@ var TestDatabaseManager = class {
         }
         return entities;
       },
-      // Memory operations
       async createMemory(memory, tableName = "messages", _unique = false) {
         const id = memory.id || v4_default();
         const fullMemory = {
@@ -228,7 +201,7 @@ var TestDatabaseManager = class {
           createdAt: memory.createdAt || Date.now()
         };
         if (!storage.memories.has(tableName)) {
-          storage.memories.set(tableName, /* @__PURE__ */ new Map());
+          storage.memories.set(tableName, new Map);
         }
         storage.memories.get(tableName).set(id, fullMemory);
         return id;
@@ -263,9 +236,7 @@ var TestDatabaseManager = class {
           memories = memories.filter((m) => m.roomId === params.roomId);
         }
         if (params.query) {
-          memories = memories.filter(
-            (m) => m.content?.text?.toLowerCase().includes(params.query.toLowerCase())
-          );
+          memories = memories.filter((m) => m.content?.text?.toLowerCase().includes(params.query.toLowerCase()));
         }
         return memories.slice(0, params.count || 10);
       },
@@ -297,9 +268,7 @@ var TestDatabaseManager = class {
         if (!tableData) {
           return [];
         }
-        let memories = Array.from(tableData.values()).filter(
-          (m) => params.roomIds.includes(m.roomId)
-        );
+        let memories = Array.from(tableData.values()).filter((m) => params.roomIds.includes(m.roomId));
         if (params.limit) {
           memories = memories.slice(0, params.limit);
         }
@@ -310,13 +279,13 @@ var TestDatabaseManager = class {
       },
       async log(params) {
         if (!storage.logs) {
-          storage.logs = /* @__PURE__ */ new Map();
+          storage.logs = new Map;
         }
         const logId = v4_default();
         storage.logs.set(logId, {
           id: logId,
           ...params,
-          createdAt: /* @__PURE__ */ new Date()
+          createdAt: new Date
         });
       },
       async getLogs() {
@@ -332,7 +301,6 @@ var TestDatabaseManager = class {
         }
         return false;
       },
-      // Room operations
       async createRoom(room) {
         const id = room.id || v4_default();
         const fullRoom = { ...room, id };
@@ -342,11 +310,8 @@ var TestDatabaseManager = class {
         return storage.rooms.get(roomId) || null;
       },
       async getRooms(worldId) {
-        return Array.from(storage.rooms.values()).filter(
-          (room) => !worldId || room.worldId === worldId
-        );
+        return Array.from(storage.rooms.values()).filter((room) => !worldId || room.worldId === worldId);
       },
-      // Participant operations
       async addParticipant(entityId, roomId) {
         const participantId = `${entityId}-${roomId}`;
         storage.participants.set(participantId, { entityId, roomId });
@@ -359,7 +324,6 @@ var TestDatabaseManager = class {
       async getParticipantsForRoom(roomId) {
         return Array.from(storage.participants.values()).filter((p) => p.roomId === roomId).map((p) => p.entityId);
       },
-      // Cache operations
       async setCache(key, value) {
         storage.cache.set(key, {
           value,
@@ -374,7 +338,6 @@ var TestDatabaseManager = class {
       async deleteCache(key) {
         return storage.cache.delete(key);
       },
-      // World operations
       async createWorld(world) {
         const id = world.id || v4_default();
         const fullWorld = { ...world, id };
@@ -387,7 +350,6 @@ var TestDatabaseManager = class {
       async getAllWorlds() {
         return Array.from(storage.worlds.values());
       },
-      // Task operations
       async createTask(task) {
         const id = task.id || v4_default();
         const fullTask = {
@@ -404,16 +366,13 @@ var TestDatabaseManager = class {
           tasks = tasks.filter((task) => task.roomId === params.roomId);
         }
         if (params.tags) {
-          tasks = tasks.filter(
-            (task) => params.tags.some((tag) => task.tags.includes(tag))
-          );
+          tasks = tasks.filter((task) => params.tags.some((tag) => task.tags.includes(tag)));
         }
         return tasks;
       },
       async deleteTask(taskId) {
         storage.tasks.delete(taskId);
       },
-      // Relationship operations
       async createRelationship(relationship) {
         const id = v4_default();
         const fullRelationship = { ...relationship, id };
@@ -423,9 +382,7 @@ var TestDatabaseManager = class {
       async getRelationships(params) {
         let relationships = Array.from(storage.relationships.values());
         if (params.entityId) {
-          relationships = relationships.filter(
-            (rel) => rel.sourceEntityId === params.entityId || rel.targetEntityId === params.entityId
-          );
+          relationships = relationships.filter((rel) => rel.sourceEntityId === params.entityId || rel.targetEntityId === params.entityId);
         }
         return relationships;
       },
@@ -584,20 +541,16 @@ var TestDatabaseManager = class {
         if (!entity?.components) {
           return null;
         }
-        return entity.components.find(
-          (c) => c.type === type && (!worldId || c.worldId === worldId) && (!sourceEntityId || c.sourceEntityId === sourceEntityId)
-        ) || null;
+        return entity.components.find((c) => c.type === type && (!worldId || c.worldId === worldId) && (!sourceEntityId || c.sourceEntityId === sourceEntityId)) || null;
       },
       async getParticipantsForEntity(entityId) {
-        return Array.from(storage.participants.values()).filter(
-          (p) => p.entityId === entityId
-        );
+        return Array.from(storage.participants.values()).filter((p) => p.entityId === entityId);
       },
       async getRoomsForParticipant(entityId) {
         return Array.from(storage.participants.values()).filter((p) => p.entityId === entityId).map((p) => p.roomId);
       },
       async getRoomsForParticipants(userIds) {
-        const roomIds = /* @__PURE__ */ new Set();
+        const roomIds = new Set;
         for (const participant of storage.participants.values()) {
           if (userIds.includes(participant.entityId)) {
             roomIds.add(participant.roomId);
@@ -608,13 +561,10 @@ var TestDatabaseManager = class {
       async getParticipantUserState(_roomId, _entityId) {
         return null;
       },
-      async setParticipantUserState(_roomId, _entityId, _state) {
-      },
+      async setParticipantUserState(_roomId, _entityId, _state) {},
       async getRelationship(params) {
         const relationships = Array.from(storage.relationships.values());
-        return relationships.find(
-          (r) => r.sourceEntityId === params.sourceEntityId && r.targetEntityId === params.targetEntityId
-        ) || null;
+        return relationships.find((r) => r.sourceEntityId === params.sourceEntityId && r.targetEntityId === params.targetEntityId) || null;
       },
       async updateRelationship(relationship) {
         if (!relationship.id || !storage.relationships.has(relationship.id)) {
@@ -647,9 +597,7 @@ var TestDatabaseManager = class {
         if (!tableData) {
           return [];
         }
-        let memories = Array.from(tableData.values()).filter(
-          (m) => m.worldId === params.worldId
-        );
+        let memories = Array.from(tableData.values()).filter((m) => m.worldId === params.worldId);
         if (params.count) {
           memories = memories.slice(0, params.count);
         }
@@ -687,9 +635,6 @@ var TestDatabaseManager = class {
     };
     return adapter;
   }
-  /**
-   * Cleanup a specific test database
-   */
   async cleanupDatabase(testId) {
     try {
       const adapter = this.testDatabases.get(testId);
@@ -699,27 +644,17 @@ var TestDatabaseManager = class {
         logger.debug(`Cleaned up database for ${testId}`);
       }
     } catch (error) {
-      logger.warn(
-        `Error cleaning up database ${testId}: ${error instanceof Error ? error.message : String(error)}`
-      );
+      logger.warn(`Error cleaning up database ${testId}: ${error instanceof Error ? error.message : String(error)}`);
     }
   }
-  /**
-   * Cleanup all test databases
-   */
   async cleanup() {
     logger.debug("Cleaning up all test databases");
-    const cleanupPromises = Array.from(this.testDatabases.keys()).map(
-      (testId) => this.cleanupDatabase(testId)
-    );
+    const cleanupPromises = Array.from(this.testDatabases.keys()).map((testId) => this.cleanupDatabase(testId));
     await Promise.all(cleanupPromises);
     this.tempPaths.clear();
     this.testDatabases.clear();
     logger.debug("Successfully cleaned up all test databases");
   }
-  /**
-   * Get statistics about test databases
-   */
   getStats() {
     return {
       activeDatabases: this.testDatabases.size,
@@ -727,18 +662,19 @@ var TestDatabaseManager = class {
       memoryUsage: `${Math.round(process.memoryUsage().heapUsed / 1024 / 1024)}MB`
     };
   }
-};
+}
 async function createTestDatabase(testId) {
   const actualTestId = testId || `test-${v4_default().slice(0, 8)}`;
-  const manager = new TestDatabaseManager();
+  const manager = new TestDatabaseManager;
   const adapter = await manager.createIsolatedDatabase(actualTestId);
   return { adapter, manager, testId: actualTestId };
 }
 
 // src/testModels.ts
 import { logger as logger2 } from "@elizaos/core";
-var TestModelProvider = class {
-  responses = /* @__PURE__ */ new Map();
+
+class TestModelProvider {
+  responses = new Map;
   patterns = [];
   defaultResponse;
   contextHistory = [];
@@ -746,12 +682,8 @@ var TestModelProvider = class {
     this.defaultResponse = defaultResponse;
     this.addDefaultPatterns();
   }
-  /**
-   * Add realistic default response patterns
-   */
   addDefaultPatterns() {
     const defaultPatterns = [
-      // Greeting patterns
       {
         pattern: /^(hello|hi|hey|greetings)/i,
         response: "Hello! How can I help you today?"
@@ -760,7 +692,6 @@ var TestModelProvider = class {
         pattern: /(good morning|good afternoon|good evening)/i,
         response: "Good day! What can I assist you with?"
       },
-      // Task creation patterns
       {
         pattern: /(create|add|make).*?(todo|task|reminder)/i,
         response: "I'll create that task for you right away. Let me add it to your todo list."
@@ -769,7 +700,6 @@ var TestModelProvider = class {
         pattern: /(schedule|plan|organize)/i,
         response: "I'll help you schedule that. Let me organize this for you."
       },
-      // Information requests
       {
         pattern: /(search|find|look|query).*?(for|about)/i,
         response: "Let me search for that information. I'll look into it right away."
@@ -778,7 +708,6 @@ var TestModelProvider = class {
         pattern: /(what|how|when|where|why)/i,
         response: "Let me find that information for you. I'll provide a detailed answer."
       },
-      // Analysis and review
       {
         pattern: /(analyze|review|examine|check)/i,
         response: "I'll analyze this carefully and provide my assessment with detailed insights."
@@ -787,7 +716,6 @@ var TestModelProvider = class {
         pattern: /(explain|describe|tell me about)/i,
         response: "I'll explain that in detail for you. Here's what you need to know."
       },
-      // Action requests
       {
         pattern: /(send|email|message|notify)/i,
         response: "I'll send that message for you. Let me take care of the communication."
@@ -796,7 +724,6 @@ var TestModelProvider = class {
         pattern: /(delete|remove|cancel)/i,
         response: "I'll remove that for you. Let me handle the deletion safely."
       },
-      // File and data operations
       {
         pattern: /(save|store|backup)/i,
         response: "I'll save that information securely. Your data will be stored properly."
@@ -805,7 +732,6 @@ var TestModelProvider = class {
         pattern: /(load|open|access)/i,
         response: "I'll access that resource for you. Let me retrieve the information."
       },
-      // Problem solving
       {
         pattern: /(fix|repair|solve|troubleshoot)/i,
         response: "I'll help troubleshoot this issue. Let me analyze the problem and find a solution."
@@ -814,7 +740,6 @@ var TestModelProvider = class {
         pattern: /(help|assist|support)/i,
         response: "I'm here to help! Let me assist you with whatever you need."
       },
-      // Decision making
       {
         pattern: /(should|recommend|suggest|advise)/i,
         response: "Based on the information provided, I'd recommend the following approach."
@@ -823,7 +748,6 @@ var TestModelProvider = class {
         pattern: /(choose|select|decide)/i,
         response: "Let me help you make that decision. Here are the key factors to consider."
       },
-      // Confirmation and acknowledgment
       {
         pattern: /(yes|ok|okay|sure|agreed)/i,
         response: "Understood! I'll proceed with that as requested."
@@ -832,7 +756,6 @@ var TestModelProvider = class {
         pattern: /(no|stop|cancel|abort)/i,
         response: "Alright, I'll stop that process. Is there anything else I can help with?"
       },
-      // Complex reasoning patterns
       {
         pattern: /(if.*then|because|therefore|since)/i,
         response: "I understand the logic. Let me work through this step by step."
@@ -841,7 +764,6 @@ var TestModelProvider = class {
         pattern: /(compare|contrast|difference|similar)/i,
         response: "I'll compare these options and highlight the key differences and similarities."
       },
-      // Error handling
       {
         pattern: /(error|problem|issue|broken|failed)/i,
         response: "I see there's an issue. Let me investigate the problem and find a solution."
@@ -849,9 +771,6 @@ var TestModelProvider = class {
     ];
     this.patterns.push(...defaultPatterns);
   }
-  /**
-   * Generate text response based on prompt
-   */
   async generateText(params) {
     const prompt = params.prompt;
     try {
@@ -871,28 +790,20 @@ var TestModelProvider = class {
       this.addToHistory(prompt, intelligentResponse);
       return intelligentResponse;
     } catch (error) {
-      logger2.warn(
-        `Error in test model provider: ${error instanceof Error ? error.message : String(error)}`
-      );
+      logger2.warn(`Error in test model provider: ${error instanceof Error ? error.message : String(error)}`);
       return this.defaultResponse;
     }
   }
-  /**
-   * Generate embeddings for text (mock implementation with consistent vectors)
-   */
   async generateEmbedding(params) {
     const text = params.text;
     const hash = this.simpleHash(text);
     const embedding = [];
-    for (let i = 0; i < 1536; i++) {
+    for (let i = 0;i < 1536; i++) {
       const value = Math.sin(hash + i) * 0.5;
       embedding.push(value);
     }
     return embedding;
   }
-  /**
-   * Generate object-structured responses
-   */
   async generateObject(params) {
     const prompt = params.prompt;
     if (prompt.includes("thought") || prompt.includes("reasoning")) {
@@ -925,23 +836,14 @@ var TestModelProvider = class {
       }
     };
   }
-  /**
-   * Make response more contextual based on prompt content
-   */
   makeContextual(response, prompt) {
     const keyTerms = this.extractKeyTerms(prompt);
     if (keyTerms.length > 0) {
       const term = keyTerms[0];
-      return response.replace(
-        /that|this|it/g,
-        term.length > 20 ? `that ${term.substring(0, 20)}...` : `that ${term}`
-      );
+      return response.replace(/that|this|it/g, term.length > 20 ? `that ${term.substring(0, 20)}...` : `that ${term}`);
     }
     return response;
   }
-  /**
-   * Generate intelligent default response based on prompt analysis
-   */
   generateIntelligentDefault(prompt) {
     const lowerPrompt = prompt.toLowerCase();
     if (lowerPrompt.includes("?")) {
@@ -958,11 +860,8 @@ var TestModelProvider = class {
     }
     return this.defaultResponse;
   }
-  /**
-   * Extract key terms from prompt for contextualization
-   */
   extractKeyTerms(prompt) {
-    const commonWords = /* @__PURE__ */ new Set([
+    const commonWords = new Set([
       "the",
       "a",
       "an",
@@ -1013,64 +912,43 @@ var TestModelProvider = class {
     const words = prompt.toLowerCase().replace(/[^\w\s]/g, " ").split(/\s+/).filter((word) => word.length > 2 && !commonWords.has(word));
     return [...new Set(words)].slice(0, 3);
   }
-  /**
-   * Simple hash function for deterministic embeddings
-   */
   simpleHash(str) {
     let hash = 0;
-    for (let i = 0; i < str.length; i++) {
+    for (let i = 0;i < str.length; i++) {
       const char = str.charCodeAt(i);
       hash = (hash << 5) - hash + char;
       hash = hash & hash;
     }
     return Math.abs(hash);
   }
-  /**
-   * Add interaction to context history
-   */
   addToHistory(prompt, response) {
     this.contextHistory.push({ prompt, response });
     if (this.contextHistory.length > 10) {
       this.contextHistory.shift();
     }
   }
-  /**
-   * Set a specific response for a prompt
-   */
   setResponse(prompt, response) {
     this.responses.set(prompt, response);
   }
-  /**
-   * Add a pattern-based response
-   */
   addPattern(pattern, response) {
     this.patterns.unshift({ pattern, response });
   }
-  /**
-   * Set the default response
-   */
   setDefaultResponse(response) {
     this.defaultResponse = response;
   }
-  /**
-   * Clear all custom responses and patterns
-   */
   clear() {
     this.responses.clear();
     this.patterns.length = 0;
     this.contextHistory.length = 0;
     this.addDefaultPatterns();
   }
-  /**
-   * Get conversation history
-   */
   getHistory() {
     return [...this.contextHistory];
   }
-};
-function createTestModelProvider(scenarios2 = [], defaultResponse) {
+}
+function createTestModelProvider(scenarios = [], defaultResponse) {
   const provider = new TestModelProvider(defaultResponse);
-  for (const scenario of scenarios2) {
+  for (const scenario of scenarios) {
     if (scenario.prompt instanceof RegExp) {
       provider.addPattern(scenario.prompt, scenario.response);
     } else {
@@ -1080,31 +958,19 @@ function createTestModelProvider(scenarios2 = [], defaultResponse) {
   return provider;
 }
 function createSpecializedModelProvider(type) {
-  const provider = new TestModelProvider();
+  const provider = new TestModelProvider;
   switch (type) {
     case "conversational":
-      provider.addPattern(
-        /.*/,
-        "That's interesting! Let me respond thoughtfully to what you've shared."
-      );
+      provider.addPattern(/.*/, "That's interesting! Let me respond thoughtfully to what you've shared.");
       break;
     case "analytical":
-      provider.addPattern(
-        /.*/,
-        "Let me analyze this systematically. Based on the data and context provided, here's my assessment."
-      );
+      provider.addPattern(/.*/, "Let me analyze this systematically. Based on the data and context provided, here's my assessment.");
       break;
     case "creative":
-      provider.addPattern(
-        /.*/,
-        "What a creative challenge! Let me think outside the box and explore innovative possibilities."
-      );
+      provider.addPattern(/.*/, "What a creative challenge! Let me think outside the box and explore innovative possibilities.");
       break;
     case "factual":
-      provider.addPattern(
-        /.*/,
-        "Based on factual information and established knowledge, here's an accurate response."
-      );
+      provider.addPattern(/.*/, "Based on factual information and established knowledge, here's an accurate response.");
       break;
   }
   return provider;
@@ -1126,7 +992,8 @@ function createModelHandler(provider) {
     }
   };
 }
-var TestScenarioBuilder = class {
+
+class TestScenarioBuilder {
   scenarios = [];
   addGreeting(response = "Hello! How can I help you?") {
     this.scenarios.push({
@@ -1156,30 +1023,24 @@ var TestScenarioBuilder = class {
   build(defaultResponse) {
     return createTestModelProvider(this.scenarios, defaultResponse);
   }
-};
+}
 function scenarios() {
-  return new TestScenarioBuilder();
+  return new TestScenarioBuilder;
 }
 
 // src/realRuntime.ts
-var RuntimeTestHarness = class {
-  runtimes = /* @__PURE__ */ new Map();
+class RuntimeTestHarness {
+  runtimes = new Map;
   databaseManager;
   testId;
   constructor(testId) {
     this.testId = testId || `test-${v4_default().slice(0, 8)}`;
-    this.databaseManager = new TestDatabaseManager();
+    this.databaseManager = new TestDatabaseManager;
   }
-  /**
-   * Creates an AgentRuntime instance for testing
-   * This uses the standard AgentRuntime - it will actually execute all functionality
-   */
   async createTestRuntime(config) {
     try {
       logger3.info(`Creating real test runtime for ${this.testId}`);
-      const databaseAdapter = await this.databaseManager.createIsolatedDatabase(
-        `${this.testId}-${Date.now()}`
-      );
+      const databaseAdapter = await this.databaseManager.createIsolatedDatabase(`${this.testId}-${Date.now()}`);
       const runtime = new AgentRuntime({
         character: config.character,
         adapter: databaseAdapter
@@ -1197,18 +1058,10 @@ var RuntimeTestHarness = class {
       logger3.info(`Successfully created real runtime ${runtime.agentId}`);
       return runtime;
     } catch (error) {
-      logger3.error(
-        `Failed to create test runtime: ${error instanceof Error ? error.message : String(error)}`
-      );
-      throw new Error(
-        `Test runtime creation failed: ${error instanceof Error ? error.message : String(error)}`
-      );
+      logger3.error(`Failed to create test runtime: ${error instanceof Error ? error.message : String(error)}`);
+      throw new Error(`Test runtime creation failed: ${error instanceof Error ? error.message : String(error)}`);
     }
   }
-  /**
-   * Loads a plugin by name from the ElizaOS ecosystem
-   * Uses dynamic imports to avoid circular dependencies during build
-   */
   async loadPlugin(pluginName) {
     try {
       logger3.info(`Attempting to load plugin: ${pluginName}`);
@@ -1216,9 +1069,7 @@ var RuntimeTestHarness = class {
       try {
         pluginModule = await import(pluginName);
       } catch (importError) {
-        logger3.warn(
-          `Could not import ${pluginName}: ${importError instanceof Error ? importError.message : String(importError)}`
-        );
+        logger3.warn(`Could not import ${pluginName}: ${importError instanceof Error ? importError.message : String(importError)}`);
         throw importError;
       }
       const plugin = pluginModule.default || pluginModule[Object.keys(pluginModule)[0]];
@@ -1228,17 +1079,10 @@ var RuntimeTestHarness = class {
       logger3.info(`Successfully loaded plugin: ${pluginName}`);
       return plugin;
     } catch (error) {
-      logger3.error(
-        `Failed to load plugin ${pluginName}: ${error instanceof Error ? error.message : String(error)}`
-      );
-      throw new Error(
-        `Plugin ${pluginName} must be available for testing. Install it before running tests. Error: ${error instanceof Error ? error.message : String(error)}`
-      );
+      logger3.error(`Failed to load plugin ${pluginName}: ${error instanceof Error ? error.message : String(error)}`);
+      throw new Error(`Plugin ${pluginName} must be available for testing. Install it before running tests. Error: ${error instanceof Error ? error.message : String(error)}`);
     }
   }
-  /**
-   * Creates a test model provider that gives realistic responses
-   */
   createRealisticModelProvider(scenarios2) {
     const defaultScenarios = [
       {
@@ -1260,9 +1104,6 @@ var RuntimeTestHarness = class {
     ];
     return createTestModelProvider(scenarios2 || defaultScenarios);
   }
-  /**
-   * Executes a real message processing test
-   */
   async processTestMessage(runtime, messageText, options = {}) {
     const startTime = Date.now();
     const roomId = options.roomId || stringToUuid(`test-room-${v4_default()}`);
@@ -1279,7 +1120,7 @@ var RuntimeTestHarness = class {
         createdAt: Date.now()
       };
       const _messageId = await runtime.createMemory(memory, "messages");
-      const responses = await runtime.processActions(memory, [], void 0, void 0);
+      const responses = await runtime.processActions(memory, [], undefined, undefined);
       const responseTime = Date.now() - startTime;
       const result = {
         scenarioName: `Process: "${messageText}"`,
@@ -1291,9 +1132,7 @@ var RuntimeTestHarness = class {
       };
       if (options.expectedActions && options.expectedActions.length > 0) {
         const executedActions = await this.getExecutedActions(runtime, roomId);
-        const missingActions = options.expectedActions.filter(
-          (action) => !executedActions.includes(action)
-        );
+        const missingActions = options.expectedActions.filter((action) => !executedActions.includes(action));
         if (missingActions.length > 0) {
           result.passed = false;
           result.errors.push(`Missing expected actions: ${missingActions.join(", ")}`);
@@ -1302,9 +1141,7 @@ var RuntimeTestHarness = class {
       }
       if (options.timeoutMs && responseTime > options.timeoutMs) {
         result.passed = false;
-        result.errors.push(
-          `Response time ${responseTime}ms exceeded timeout ${options.timeoutMs}ms`
-        );
+        result.errors.push(`Response time ${responseTime}ms exceeded timeout ${options.timeoutMs}ms`);
       }
       return result;
     } catch (error) {
@@ -1318,9 +1155,6 @@ var RuntimeTestHarness = class {
       };
     }
   }
-  /**
-   * Gets actions that were actually executed (not mocked)
-   */
   async getExecutedActions(runtime, roomId) {
     try {
       const memories = await runtime.getMemories({
@@ -1336,15 +1170,10 @@ var RuntimeTestHarness = class {
       }
       return [...new Set(actions)];
     } catch (error) {
-      logger3.warn(
-        `Could not retrieve executed actions: ${error instanceof Error ? error.message : String(error)}`
-      );
+      logger3.warn(`Could not retrieve executed actions: ${error instanceof Error ? error.message : String(error)}`);
       return [];
     }
   }
-  /**
-   * Validates that a runtime is actually functional
-   */
   async validateRuntimeHealth(runtime) {
     const issues = [];
     const services = [];
@@ -1366,12 +1195,10 @@ var RuntimeTestHarness = class {
         };
         await runtime.createMemory(healthMemory, "test");
       } catch (error) {
-        issues.push(
-          `Database not functional: ${error instanceof Error ? error.message : String(error)}`
-        );
+        issues.push(`Database not functional: ${error instanceof Error ? error.message : String(error)}`);
       }
       try {
-        const serviceMap = runtime.services || /* @__PURE__ */ new Map();
+        const serviceMap = runtime.services || new Map;
         for (const [name, service] of serviceMap) {
           services.push(name);
           if (!service) {
@@ -1379,16 +1206,12 @@ var RuntimeTestHarness = class {
           }
         }
       } catch (error) {
-        issues.push(
-          `Services not accessible: ${error instanceof Error ? error.message : String(error)}`
-        );
+        issues.push(`Services not accessible: ${error instanceof Error ? error.message : String(error)}`);
       }
       try {
         plugins.push(...runtime.plugins?.map((p) => p.name) || []);
       } catch (error) {
-        issues.push(
-          `Plugins not accessible: ${error instanceof Error ? error.message : String(error)}`
-        );
+        issues.push(`Plugins not accessible: ${error instanceof Error ? error.message : String(error)}`);
       }
       return {
         healthy: issues.length === 0,
@@ -1407,9 +1230,6 @@ var RuntimeTestHarness = class {
       };
     }
   }
-  /**
-   * Cleanup all test resources
-   */
   async cleanup() {
     try {
       logger3.info(`Cleaning up test harness ${this.testId}`);
@@ -1418,24 +1238,20 @@ var RuntimeTestHarness = class {
           await runtime.stop();
           logger3.debug(`Stopped runtime ${runtimeId}`);
         } catch (error) {
-          logger3.warn(
-            `Error stopping runtime ${runtimeId}: ${error instanceof Error ? error.message : String(error)}`
-          );
+          logger3.warn(`Error stopping runtime ${runtimeId}: ${error instanceof Error ? error.message : String(error)}`);
         }
       }
       this.runtimes.clear();
       await this.databaseManager.cleanup();
       logger3.info(`Successfully cleaned up test harness ${this.testId}`);
     } catch (error) {
-      logger3.error(
-        `Error during cleanup: ${error instanceof Error ? error.message : String(error)}`
-      );
+      logger3.error(`Error during cleanup: ${error instanceof Error ? error.message : String(error)}`);
       throw error;
     }
   }
-};
+}
 async function createTestRuntime(config = {}) {
-  const harness = new RuntimeTestHarness();
+  const harness = new RuntimeTestHarness;
   const defaultCharacter = {
     name: "TestAgent",
     system: "You are a helpful test agent.",
@@ -1484,10 +1300,9 @@ async function runIntegrationTest(testName, testFn, config) {
     }
   }
 }
-
 // src/templates.ts
 import { logger as logger4 } from "@elizaos/core";
-var TestTemplate = class {
+class TestTemplate {
   config;
   runtime;
   constructor(config) {
@@ -1509,8 +1324,9 @@ var TestTemplate = class {
   getConfig() {
     return this.config;
   }
-};
-var UnitTestTemplate = class extends TestTemplate {
+}
+
+class UnitTestTemplate extends TestTemplate {
   testFunction;
   constructor(config, testFunction) {
     super(config);
@@ -1545,8 +1361,9 @@ var UnitTestTemplate = class extends TestTemplate {
       await this.teardown();
     }
   }
-};
-var IntegrationTestTemplate = class extends TestTemplate {
+}
+
+class IntegrationTestTemplate extends TestTemplate {
   testFunction;
   character;
   constructor(config, testFunction, character) {
@@ -1587,8 +1404,9 @@ var IntegrationTestTemplate = class extends TestTemplate {
       await this.teardown();
     }
   }
-};
-var PluginTestTemplate = class extends TestTemplate {
+}
+
+class PluginTestTemplate extends TestTemplate {
   plugin;
   testFunction;
   constructor(config, plugin, testFunction) {
@@ -1633,8 +1451,9 @@ var PluginTestTemplate = class extends TestTemplate {
       await this.teardown();
     }
   }
-};
-var ErrorTestTemplate = class extends TestTemplate {
+}
+
+class ErrorTestTemplate extends TestTemplate {
   testFunction;
   expectedError;
   constructor(config, testFunction, expectedError) {
@@ -1667,14 +1486,15 @@ var ErrorTestTemplate = class extends TestTemplate {
         name: this.config.name,
         passed,
         duration: Date.now() - startTime,
-        error: passed ? void 0 : error instanceof Error ? error : new Error(String(error))
+        error: passed ? undefined : error instanceof Error ? error : new Error(String(error))
       };
     } finally {
       await this.teardown();
     }
   }
-};
-var PerformanceTestTemplate = class extends TestTemplate {
+}
+
+class PerformanceTestTemplate extends TestTemplate {
   testFunction;
   maxDuration;
   maxMemoryMB;
@@ -1707,9 +1527,7 @@ var PerformanceTestTemplate = class extends TestTemplate {
         passed = false;
       }
       if (memoryUsed > this.maxMemoryMB) {
-        warnings.push(
-          `Test exceeded max memory: ${memoryUsed.toFixed(2)}MB > ${this.maxMemoryMB}MB`
-        );
+        warnings.push(`Test exceeded max memory: ${memoryUsed.toFixed(2)}MB > ${this.maxMemoryMB}MB`);
         passed = false;
       }
       return {
@@ -1734,8 +1552,9 @@ var PerformanceTestTemplate = class extends TestTemplate {
       await this.teardown();
     }
   }
-};
-var TestSuite = class {
+}
+
+class TestSuite {
   tests = [];
   name;
   constructor(name) {
@@ -1753,9 +1572,9 @@ var TestSuite = class {
         const result = await test.execute();
         results.push(result);
         if (result.passed) {
-          logger4.info(`\u2713 ${result.name} (${result.duration}ms)`);
+          logger4.info(`✓ ${result.name} (${result.duration}ms)`);
         } else {
-          logger4.error(`\u2717 ${result.name} (${result.duration}ms): ${result.error?.message}`);
+          logger4.error(`✗ ${result.name} (${result.duration}ms): ${result.error?.message}`);
         }
       } catch (error) {
         const errorResult = {
@@ -1765,15 +1584,13 @@ var TestSuite = class {
           error: error instanceof Error ? error : new Error(String(error))
         };
         results.push(errorResult);
-        logger4.error(`\u2717 ${errorResult.name}: ${errorResult.error?.message}`);
+        logger4.error(`✗ ${errorResult.name}: ${errorResult.error?.message}`);
       }
     }
     const passed = results.filter((r) => r.passed).length;
     const failed = results.length - passed;
     const duration = Date.now() - startTime;
-    logger4.info(
-      `Test suite ${this.name} completed: ${passed}/${results.length} passed (${duration}ms)`
-    );
+    logger4.info(`Test suite ${this.name} completed: ${passed}/${results.length} passed (${duration}ms)`);
     return {
       suiteName: this.name,
       totalTests: results.length,
@@ -1783,28 +1600,24 @@ var TestSuite = class {
       results
     };
   }
-};
+}
 function createUnitTest(name, testFunction, options = {}) {
-  return new UnitTestTemplate({ name, timeout: 5e3, ...options }, testFunction);
+  return new UnitTestTemplate({ name, timeout: 5000, ...options }, testFunction);
 }
 function createIntegrationTest(name, testFunction, character, options = {}) {
-  return new IntegrationTestTemplate({ name, timeout: 3e4, ...options }, testFunction, character);
+  return new IntegrationTestTemplate({ name, timeout: 30000, ...options }, testFunction, character);
 }
 function createPluginTest(name, plugin, testFunction, options = {}) {
-  return new PluginTestTemplate({ name, timeout: 3e4, ...options }, plugin, testFunction);
+  return new PluginTestTemplate({ name, timeout: 30000, ...options }, plugin, testFunction);
 }
 function createErrorTest(name, testFunction, expectedError, options = {}) {
-  return new ErrorTestTemplate({ name, timeout: 5e3, ...options }, testFunction, expectedError);
+  return new ErrorTestTemplate({ name, timeout: 5000, ...options }, testFunction, expectedError);
 }
 function createPerformanceTest(name, testFunction, maxDurationMs, maxMemoryMB, options = {}) {
-  return new PerformanceTestTemplate(
-    { name, timeout: maxDurationMs * 2, ...options },
-    testFunction,
-    maxDurationMs,
-    maxMemoryMB
-  );
-}
-var TestDataGenerator = class {
+  return new PerformanceTestTemplate({ name, timeout: maxDurationMs * 2, ...options }, testFunction, maxDurationMs, maxMemoryMB);
+}
+
+class TestDataGenerator {
   static generateUUID() {
     return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
       const r = Math.random() * 16 | 0;
@@ -1839,8 +1652,7 @@ var TestDataGenerator = class {
       ...overrides
     };
   }
-};
-
+}
 // src/mocks/mockUtils.ts
 function mock(implementation) {
   const calls = [];
@@ -1924,28 +1736,25 @@ function createMockRuntime(overrides = {}) {
     get: mock().mockResolvedValue(null)
   };
   const baseRuntime = {
-    // Core Properties
     agentId: "test-agent-id",
     character: overrides.character || defaultCharacter,
     providers: overrides.providers || [],
     actions: overrides.actions || [],
     evaluators: overrides.evaluators || [],
     plugins: overrides.plugins || [],
-    services: overrides.services || /* @__PURE__ */ new Map(),
-    events: overrides.events || /* @__PURE__ */ new Map(),
+    services: overrides.services || new Map,
+    events: overrides.events || new Map,
     fetch: overrides.fetch || null,
     routes: overrides.routes || [],
     logger: overrides.logger || console,
-    // Database Properties
     db: overrides.db || mockDb,
-    // Core Runtime Methods
-    registerPlugin: mock().mockResolvedValue(void 0),
-    initialize: mock().mockResolvedValue(void 0),
+    registerPlugin: mock().mockResolvedValue(undefined),
+    initialize: mock().mockResolvedValue(undefined),
     getConnection: mock().mockResolvedValue(mockDb),
     getService: mock().mockReturnValue(null),
     getServicesByType: mock().mockReturnValue([]),
-    getAllServices: mock().mockReturnValue(/* @__PURE__ */ new Map()),
-    registerService: mock().mockResolvedValue(void 0),
+    getAllServices: mock().mockReturnValue(new Map),
+    registerService: mock().mockResolvedValue(undefined),
     getServiceLoadPromise: mock().mockResolvedValue(null),
     getRegisteredServiceTypes: mock().mockReturnValue([]),
     hasService: mock().mockReturnValue(false),
@@ -1959,16 +1768,16 @@ function createMockRuntime(overrides = {}) {
       return defaultSettings[key];
     }),
     getConversationLength: mock().mockReturnValue(10),
-    processActions: mock().mockResolvedValue(void 0),
+    processActions: mock().mockResolvedValue(undefined),
     evaluate: mock().mockResolvedValue([]),
     registerProvider: mock(),
     registerAction: mock(),
     registerEvaluator: mock(),
-    ensureConnection: mock().mockResolvedValue(void 0),
-    ensureConnections: mock().mockResolvedValue(void 0),
-    ensureParticipantInRoom: mock().mockResolvedValue(void 0),
-    ensureWorldExists: mock().mockResolvedValue(void 0),
-    ensureRoomExists: mock().mockResolvedValue(void 0),
+    ensureConnection: mock().mockResolvedValue(undefined),
+    ensureConnections: mock().mockResolvedValue(undefined),
+    ensureParticipantInRoom: mock().mockResolvedValue(undefined),
+    ensureWorldExists: mock().mockResolvedValue(undefined),
+    ensureRoomExists: mock().mockResolvedValue(undefined),
     composeState: mock().mockResolvedValue({
       values: {},
       data: {},
@@ -1976,107 +1785,96 @@ function createMockRuntime(overrides = {}) {
     }),
     useModel: mock().mockResolvedValue("Mock response"),
     registerModel: mock(),
-    getModel: mock().mockReturnValue(void 0),
+    getModel: mock().mockReturnValue(undefined),
     registerEvent: mock(),
-    getEvent: mock().mockReturnValue(void 0),
-    emitEvent: mock().mockResolvedValue(void 0),
+    getEvent: mock().mockReturnValue(undefined),
+    emitEvent: mock().mockResolvedValue(undefined),
     registerTaskWorker: mock(),
-    getTaskWorker: mock().mockReturnValue(void 0),
-    stop: mock().mockResolvedValue(void 0),
+    getTaskWorker: mock().mockReturnValue(undefined),
+    stop: mock().mockResolvedValue(undefined),
     addEmbeddingToMemory: mock().mockImplementation((memory) => Promise.resolve(memory)),
-    queueEmbeddingGeneration: mock().mockResolvedValue(void 0),
+    queueEmbeddingGeneration: mock().mockResolvedValue(undefined),
     createRunId: mock().mockReturnValue("test-run-id"),
     startRun: mock().mockReturnValue("test-run-id"),
     endRun: mock(),
     getCurrentRunId: mock().mockReturnValue("test-run-id"),
     registerSendHandler: mock(),
-    sendMessageToTarget: mock().mockResolvedValue(void 0),
-    // Database Adapter Methods - Agent Management
-    init: mock().mockResolvedValue(void 0),
+    sendMessageToTarget: mock().mockResolvedValue(undefined),
+    init: mock().mockResolvedValue(undefined),
     isReady: mock().mockResolvedValue(true),
-    runMigrations: mock().mockResolvedValue(void 0),
-    close: mock().mockResolvedValue(void 0),
+    runMigrations: mock().mockResolvedValue(undefined),
+    close: mock().mockResolvedValue(undefined),
     getAgent: mock().mockResolvedValue(null),
     getAgents: mock().mockResolvedValue([]),
     createAgent: mock().mockResolvedValue(true),
     updateAgent: mock().mockResolvedValue(true),
     deleteAgent: mock().mockResolvedValue(true),
-    // Entity Management
     getEntityById: mock().mockResolvedValue(null),
     getEntitiesByIds: mock().mockResolvedValue([]),
     getEntitiesForRoom: mock().mockResolvedValue([]),
     createEntity: mock().mockResolvedValue("test-entity-id"),
     createEntities: mock().mockResolvedValue(true),
-    updateEntity: mock().mockResolvedValue(void 0),
-    // Component Management
+    updateEntity: mock().mockResolvedValue(undefined),
     getComponent: mock().mockResolvedValue(null),
     getComponents: mock().mockResolvedValue([]),
     createComponent: mock().mockResolvedValue("test-component-id"),
-    updateComponent: mock().mockResolvedValue(void 0),
-    deleteComponent: mock().mockResolvedValue(void 0),
-    // Memory Management
+    updateComponent: mock().mockResolvedValue(undefined),
+    deleteComponent: mock().mockResolvedValue(undefined),
     getMemories: mock().mockResolvedValue([]),
     getAllMemories: overrides.getAllMemories || mock().mockResolvedValue([]),
-    clearAllAgentMemories: mock().mockResolvedValue(void 0),
+    clearAllAgentMemories: mock().mockResolvedValue(undefined),
     getMemoryById: mock().mockResolvedValue(null),
     getMemoriesByIds: mock().mockResolvedValue([]),
     getMemoriesByRoomIds: mock().mockResolvedValue([]),
     getMemoriesByWorldId: mock().mockResolvedValue([]),
     getCachedEmbeddings: mock().mockResolvedValue([]),
-    log: mock().mockResolvedValue(void 0),
+    log: mock().mockResolvedValue(undefined),
     getLogs: mock().mockResolvedValue([]),
-    deleteLog: mock().mockResolvedValue(void 0),
+    deleteLog: mock().mockResolvedValue(undefined),
     searchMemories: mock().mockResolvedValue([]),
     createMemory: mock().mockResolvedValue("test-memory-id"),
     updateMemory: mock().mockResolvedValue(true),
-    deleteMemory: mock().mockResolvedValue(void 0),
-    deleteManyMemories: mock().mockResolvedValue(void 0),
-    deleteAllMemories: mock().mockResolvedValue(void 0),
+    deleteMemory: mock().mockResolvedValue(undefined),
+    deleteManyMemories: mock().mockResolvedValue(undefined),
+    deleteAllMemories: mock().mockResolvedValue(undefined),
     countMemories: mock().mockResolvedValue(0),
-    ensureEmbeddingDimension: mock().mockResolvedValue(void 0),
-    // World Management
+    ensureEmbeddingDimension: mock().mockResolvedValue(undefined),
     createWorld: mock().mockResolvedValue("test-world-id"),
     getWorld: mock().mockResolvedValue(null),
-    removeWorld: mock().mockResolvedValue(void 0),
+    removeWorld: mock().mockResolvedValue(undefined),
     getAllWorlds: mock().mockResolvedValue([]),
-    updateWorld: mock().mockResolvedValue(void 0),
-    // Room Management
+    updateWorld: mock().mockResolvedValue(undefined),
     getRoom: mock().mockResolvedValue(null),
     getRooms: mock().mockResolvedValue([]),
     getRoomsByIds: mock().mockResolvedValue([]),
     createRoom: mock().mockResolvedValue("test-room-id"),
     createRooms: mock().mockResolvedValue([]),
-    deleteRoom: mock().mockResolvedValue(void 0),
-    deleteRoomsByWorldId: mock().mockResolvedValue(void 0),
-    updateRoom: mock().mockResolvedValue(void 0),
+    deleteRoom: mock().mockResolvedValue(undefined),
+    deleteRoomsByWorldId: mock().mockResolvedValue(undefined),
+    updateRoom: mock().mockResolvedValue(undefined),
     getRoomsForParticipant: mock().mockResolvedValue([]),
     getRoomsForParticipants: mock().mockResolvedValue([]),
     getRoomsByWorld: mock().mockResolvedValue([]),
-    // Participant Management
     addParticipant: mock().mockResolvedValue(true),
     removeParticipant: mock().mockResolvedValue(true),
     addParticipantsRoom: mock().mockResolvedValue(true),
     getParticipantsForEntity: mock().mockResolvedValue([]),
     getParticipantsForRoom: mock().mockResolvedValue([]),
     getParticipantUserState: mock().mockResolvedValue(null),
-    setParticipantUserState: mock().mockResolvedValue(void 0),
-    // Relationship Management
+    setParticipantUserState: mock().mockResolvedValue(undefined),
     createRelationship: mock().mockResolvedValue(true),
-    updateRelationship: mock().mockResolvedValue(void 0),
+    updateRelationship: mock().mockResolvedValue(undefined),
     getRelationship: mock().mockResolvedValue(null),
     getRelationships: mock().mockResolvedValue([]),
-    // Cache Management
-    getCache: mock().mockResolvedValue(void 0),
+    getCache: mock().mockResolvedValue(undefined),
     setCache: mock().mockResolvedValue(true),
     deleteCache: mock().mockResolvedValue(true),
-    // Task Management
     createTask: mock().mockResolvedValue("test-task-id"),
     getTasks: mock().mockResolvedValue([]),
     getTask: mock().mockResolvedValue(null),
     getTasksByName: mock().mockResolvedValue([]),
-    updateTask: mock().mockResolvedValue(void 0),
-    deleteTask: mock().mockResolvedValue(void 0),
-    // Apply overrides
+    updateTask: mock().mockResolvedValue(undefined),
+    deleteTask: mock().mockResolvedValue(undefined),
     ...overrides
   };
   return baseRuntime;
@@ -2103,7 +1901,7 @@ function createMockMemory(overrides = {}) {
     roomId: "test-room-id",
     worldId: "test-world-id",
     content: defaultContent,
-    embedding: void 0,
+    embedding: undefined,
     createdAt: Date.now(),
     unique: true,
     similarity: 1,
@@ -2119,9 +1917,9 @@ function createMockContent(overrides = {}) {
     actions: [],
     providers: [],
     source: "test",
-    target: void 0,
-    url: void 0,
-    inReplyTo: void 0,
+    target: undefined,
+    url: undefined,
+    inReplyTo: undefined,
     attachments: [],
     channelType: "DM",
     ...overrides
@@ -2182,12 +1980,12 @@ function createMockMemoryWithEmbedding(text, dimension = 1536, overrides = {}) {
 function createMockConversation(count = 5, roomId) {
   const memories = [];
   const actualRoomId = roomId || "test-room-id";
-  for (let i = 0; i < count; i++) {
+  for (let i = 0;i < count; i++) {
     const isUserMessage = i % 2 === 0;
     const memory = isUserMessage ? createMockUserMessage(`User message ${i + 1}`, { roomId: actualRoomId }) : createMockAgentResponse(`Agent response ${i + 1}`, `Thinking about response ${i + 1}`, [], {
       roomId: actualRoomId
     });
-    memory.createdAt = Date.now() - (count - i) * 1e3;
+    memory.createdAt = Date.now() - (count - i) * 1000;
     memories.push(memory);
   }
   return memories;
@@ -2214,9 +2012,8 @@ function createMockMedia(type = "image", url = "https://example.com/test.jpg", o
 // src/mocks/state.ts
 function createMockState(overrides = {}) {
   const baseState = {
-    // Core state properties
     values: {
-      currentTime: (/* @__PURE__ */ new Date()).toISOString(),
+      currentTime: new Date().toISOString(),
       agentName: "Test Agent",
       roomId: "test-room-id",
       entityId: "test-entity-id",
@@ -2227,7 +2024,7 @@ function createMockState(overrides = {}) {
     },
     data: {
       providers: {
-        TIME: { currentTime: (/* @__PURE__ */ new Date()).toISOString() },
+        TIME: { currentTime: new Date().toISOString() },
         CHARACTER: { agentName: "Test Agent", bio: "A helpful test assistant" },
         RECENT_MESSAGES: { messageCount: 5, lastSpeaker: "user" }
       },
@@ -2236,13 +2033,12 @@ function createMockState(overrides = {}) {
       ...overrides.data
     },
     text: `[CONTEXT]
-Current Time: ${(/* @__PURE__ */ new Date()).toISOString()}
+Current Time: ${new Date().toISOString()}
 Agent: Test Agent
 User: TestUser
 Room: test-room-id
 Recent conversation context available.
 [/CONTEXT]`,
-    // Additional properties that might be added dynamically
     ...overrides
   };
   if (overrides.text) {
@@ -2262,7 +2058,9 @@ function createMockProviderResult(overrides = {}) {
       processed: true,
       ...overrides.data
     },
-    text: "[MOCK PROVIDER]\nMock provider context information\n[/MOCK PROVIDER]",
+    text: `[MOCK PROVIDER]
+Mock provider context information
+[/MOCK PROVIDER]`,
     ...overrides
   };
   return baseResult;
@@ -2308,7 +2106,7 @@ function createMockStateWithActions(actionResults, overrides = {}) {
       ...overrides.data
     },
     values: {
-      lastActionSuccess: actionResults.length > 0 ? actionResults[actionResults.length - 1].values?.success : void 0,
+      lastActionSuccess: actionResults.length > 0 ? actionResults[actionResults.length - 1].values?.success : undefined,
       actionCount: actionResults.length,
       ...overrides.values
     },
@@ -2431,8 +2229,7 @@ function createMockCharacter(overrides = {}) {
     settings: {
       model: "gpt-4",
       temperature: 0.1,
-      // Low temperature for consistent test responses
-      maxTokens: 1e3,
+      maxTokens: 1000,
       secrets: {},
       voice: {
         model: "en_US-hfc_female-medium"
@@ -2466,7 +2263,6 @@ function createMockCharacter(overrides = {}) {
         "encourage best practices"
       ]
     },
-    // Apply all overrides
     ...overrides
   };
   return baseCharacter;
@@ -2541,7 +2337,7 @@ function createRichConversationCharacter(overrides = {}) {
 }
 function createMultipleCharacters(count = 3, baseName = "TestAgent", overrides = {}) {
   const characters = [];
-  for (let i = 1; i <= count; i++) {
+  for (let i = 1;i <= count; i++) {
     const character = createMockCharacter({
       name: `${baseName}${i}`,
       username: `${baseName.toLowerCase()}${i}`,
@@ -2574,10 +2370,7 @@ function createTestEnvironment(options = {}) {
     ...runtimeOverrides
   });
   const conversation = createMockConversation(conversationLength, roomId);
-  const state = createMockConversationState(
-    conversation.map((m) => m.content.text || ""),
-    "TestUser"
-  );
+  const state = createMockConversationState(conversation.map((m) => m.content.text || ""), "TestUser");
   return {
     runtime,
     character,
@@ -2599,18 +2392,16 @@ function createTestAction(name, options = {}) {
     description,
     examples,
     validate: mock().mockResolvedValue(validateResult),
-    handler: mock(
-      async (runtime, message, state, options2, callback) => {
-        if (callback) {
-          await callback({
-            text: handlerResult.text || `${name} action executed`,
-            thought: `Executing ${name} action`,
-            actions: [name]
-          });
-        }
-        return handlerResult;
+    handler: mock(async (runtime, message, state, options2, callback) => {
+      if (callback) {
+        await callback({
+          text: handlerResult.text || `${name} action executed`,
+          thought: `Executing ${name} action`,
+          actions: [name]
+        });
       }
-    )
+      return handlerResult;
+    })
   };
 }
 function createTestProvider(name, options = {}) {
@@ -2668,13 +2459,11 @@ function createPluginTestScenario(pluginName, options = {}) {
   const testActions = actions.map((name) => createTestAction(name));
   const testProviders = providers.map((name) => createTestProvider(name));
   const testEvaluators = evaluators.map((name) => createTestEvaluator(name));
-  const conversation = conversationSteps.map(
-    (text, index) => createMockMemory({
-      content: { text },
-      entityId: index % 2 === 0 ? "user-id" : runtime.agentId,
-      roomId
-    })
-  );
+  const conversation = conversationSteps.map((text, index) => createMockMemory({
+    content: { text },
+    entityId: index % 2 === 0 ? "user-id" : runtime.agentId,
+    roomId
+  }));
   return {
     runtime,
     character,
@@ -2686,7 +2475,6 @@ function createPluginTestScenario(pluginName, options = {}) {
       providers: testProviders,
       evaluators: testEvaluators
     },
-    // Helper methods for common test operations
     helpers: {
       executeAction: async (actionName, message) => {
         const action = testActions.find((a) => a.name === actionName);
@@ -2722,13 +2510,11 @@ function createMultiAgentScenario(agentCount = 2, options = {}) {
     });
     return { runtime, character, index };
   });
-  const conversation = conversationSteps.map(
-    (step) => createMockMemory({
-      content: { text: step.message },
-      entityId: agents[step.agentIndex].runtime.agentId,
-      roomId: sharedRoomId
-    })
-  );
+  const conversation = conversationSteps.map((step) => createMockMemory({
+    content: { text: step.message },
+    entityId: agents[step.agentIndex].runtime.agentId,
+    roomId: sharedRoomId
+  }));
   return {
     agents,
     sharedRoomId,
@@ -2749,7 +2535,6 @@ function createMultiAgentScenario(agentCount = 2, options = {}) {
     }
   };
 }
-
 // src/mocks/database.ts
 function createMockDatabase(overrides = {}) {
   const mockConnection = {
@@ -2760,33 +2545,27 @@ function createMockDatabase(overrides = {}) {
     get: mock().mockResolvedValue(null)
   };
   const baseDatabaseAdapter = {
-    // Core Database Properties
     db: overrides.db || mockConnection,
-    // Core Lifecycle Methods
-    init: mock().mockResolvedValue(void 0),
-    initialize: mock().mockResolvedValue(void 0),
+    init: mock().mockResolvedValue(undefined),
+    initialize: mock().mockResolvedValue(undefined),
     isReady: mock().mockResolvedValue(true),
-    runMigrations: mock().mockResolvedValue(void 0),
-    close: mock().mockResolvedValue(void 0),
+    runMigrations: mock().mockResolvedValue(undefined),
+    close: mock().mockResolvedValue(undefined),
     getConnection: mock().mockResolvedValue(mockConnection),
-    // Agent Management
     getAgent: mock().mockResolvedValue(null),
     getAgents: mock().mockResolvedValue([]),
     createAgent: mock().mockResolvedValue(true),
     updateAgent: mock().mockResolvedValue(true),
     deleteAgent: mock().mockResolvedValue(true),
-    // Entity Management
     getEntitiesByIds: mock().mockResolvedValue([]),
     getEntitiesForRoom: mock().mockResolvedValue([]),
     createEntities: mock().mockResolvedValue(true),
-    updateEntity: mock().mockResolvedValue(void 0),
-    // Component Management
+    updateEntity: mock().mockResolvedValue(undefined),
     getComponent: mock().mockResolvedValue(null),
     getComponents: mock().mockResolvedValue([]),
     createComponent: mock().mockResolvedValue(true),
-    updateComponent: mock().mockResolvedValue(void 0),
-    deleteComponent: mock().mockResolvedValue(void 0),
-    // Memory Management
+    updateComponent: mock().mockResolvedValue(undefined),
+    deleteComponent: mock().mockResolvedValue(undefined),
     getMemories: mock().mockResolvedValue([]),
     getMemoryById: mock().mockResolvedValue(null),
     getMemoriesByIds: mock().mockResolvedValue([]),
@@ -2796,54 +2575,46 @@ function createMockDatabase(overrides = {}) {
     searchMemories: mock().mockResolvedValue([]),
     createMemory: mock().mockResolvedValue("test-memory-id"),
     updateMemory: mock().mockResolvedValue(true),
-    deleteMemory: mock().mockResolvedValue(void 0),
-    deleteManyMemories: mock().mockResolvedValue(void 0),
-    deleteAllMemories: mock().mockResolvedValue(void 0),
+    deleteMemory: mock().mockResolvedValue(undefined),
+    deleteManyMemories: mock().mockResolvedValue(undefined),
+    deleteAllMemories: mock().mockResolvedValue(undefined),
     countMemories: mock().mockResolvedValue(0),
-    ensureEmbeddingDimension: mock().mockResolvedValue(void 0),
-    // Logging
-    log: mock().mockResolvedValue(void 0),
+    ensureEmbeddingDimension: mock().mockResolvedValue(undefined),
+    log: mock().mockResolvedValue(undefined),
     getLogs: mock().mockResolvedValue([]),
-    deleteLog: mock().mockResolvedValue(void 0),
-    // World Management
+    deleteLog: mock().mockResolvedValue(undefined),
     createWorld: mock().mockResolvedValue("test-world-id"),
     getWorld: mock().mockResolvedValue(null),
-    removeWorld: mock().mockResolvedValue(void 0),
+    removeWorld: mock().mockResolvedValue(undefined),
     getAllWorlds: mock().mockResolvedValue([]),
-    updateWorld: mock().mockResolvedValue(void 0),
-    // Room Management
+    updateWorld: mock().mockResolvedValue(undefined),
     getRoomsByIds: mock().mockResolvedValue([]),
     createRooms: mock().mockResolvedValue([]),
-    deleteRoom: mock().mockResolvedValue(void 0),
-    deleteRoomsByWorldId: mock().mockResolvedValue(void 0),
-    updateRoom: mock().mockResolvedValue(void 0),
+    deleteRoom: mock().mockResolvedValue(undefined),
+    deleteRoomsByWorldId: mock().mockResolvedValue(undefined),
+    updateRoom: mock().mockResolvedValue(undefined),
     getRoomsForParticipant: mock().mockResolvedValue([]),
     getRoomsForParticipants: mock().mockResolvedValue([]),
     getRoomsByWorld: mock().mockResolvedValue([]),
-    // Participant Management
     removeParticipant: mock().mockResolvedValue(true),
     addParticipantsRoom: mock().mockResolvedValue(true),
     getParticipantsForEntity: mock().mockResolvedValue([]),
     getParticipantsForRoom: mock().mockResolvedValue([]),
     getParticipantUserState: mock().mockResolvedValue(null),
-    setParticipantUserState: mock().mockResolvedValue(void 0),
-    // Relationship Management
+    setParticipantUserState: mock().mockResolvedValue(undefined),
     createRelationship: mock().mockResolvedValue(true),
-    updateRelationship: mock().mockResolvedValue(void 0),
+    updateRelationship: mock().mockResolvedValue(undefined),
     getRelationship: mock().mockResolvedValue(null),
     getRelationships: mock().mockResolvedValue([]),
-    // Cache Management
-    getCache: mock().mockResolvedValue(void 0),
+    getCache: mock().mockResolvedValue(undefined),
     setCache: mock().mockResolvedValue(true),
     deleteCache: mock().mockResolvedValue(true),
-    // Task Management
     createTask: mock().mockResolvedValue("test-task-id"),
     getTasks: mock().mockResolvedValue([]),
     getTask: mock().mockResolvedValue(null),
     getTasksByName: mock().mockResolvedValue([]),
-    updateTask: mock().mockResolvedValue(void 0),
-    deleteTask: mock().mockResolvedValue(void 0),
-    // Apply overrides
+    updateTask: mock().mockResolvedValue(undefined),
+    deleteTask: mock().mockResolvedValue(undefined),
     ...overrides
   };
   return baseDatabaseAdapter;
@@ -2863,31 +2634,24 @@ function createMockDbConnection(overrides = {}) {
     ...overrides
   };
 }
-
 // src/mocks/services.ts
 import { ServiceType } from "@elizaos/core";
 function createMockService(serviceType = ServiceType.UNKNOWN, overrides = {}) {
   const baseService = {
-    // Static properties (would be on the class)
     serviceType,
-    // Instance properties
     capabilityDescription: `Mock service for testing`,
     config: {
       enabled: true,
       mockData: true,
       ...overrides.config
     },
-    // Core lifecycle methods
-    stop: mock().mockResolvedValue(void 0),
-    // Common service methods that might be implemented
-    start: mock().mockResolvedValue(void 0),
-    initialize: mock().mockResolvedValue(void 0),
+    stop: mock().mockResolvedValue(undefined),
+    start: mock().mockResolvedValue(undefined),
+    initialize: mock().mockResolvedValue(undefined),
     isReady: mock().mockReturnValue(true),
     getStatus: mock().mockReturnValue("active"),
-    restart: mock().mockResolvedValue(void 0),
-    // Runtime property (protected in Service class, but needed for mocks)
+    restart: mock().mockResolvedValue(undefined),
     runtime: null,
-    // Apply overrides
     ...overrides
   };
   return baseService;
@@ -2899,7 +2663,7 @@ function createMockDatabaseService(overrides = {}) {
   });
 }
 function createMockCacheService(overrides = {}) {
-  const cache = /* @__PURE__ */ new Map();
+  const cache = new Map;
   return createMockService(ServiceType.UNKNOWN, {
     capabilityDescription: "Provides in-memory caching capabilities",
     ...overrides
@@ -2930,7 +2694,7 @@ function createMockMessagingService(overrides = {}) {
   });
 }
 function createMockServiceMap(services = []) {
-  const serviceMap = /* @__PURE__ */ new Map();
+  const serviceMap = new Map;
   if (services.length === 0) {
     services = [
       { name: "database", type: ServiceType.UNKNOWN },
@@ -2953,67 +2717,69 @@ function registerMockServices(runtime, services = []) {
   return runtime;
 }
 export {
-  ErrorTestTemplate,
-  IntegrationTestTemplate,
-  PerformanceTestTemplate,
-  PluginTestTemplate,
-  RuntimeTestHarness,
-  TestDataGenerator,
-  TestDatabaseManager,
-  TestModelProvider,
-  TestScenarioBuilder,
-  TestSuite,
-  TestTemplate,
-  UnitTestTemplate,
-  createErrorTest,
-  createIntegrationTest,
-  createMinimalMockCharacter,
-  createMockActionResult,
-  createMockAgentResponse,
-  createMockBlockchainService,
-  createMockCacheService,
-  createMockCharacter,
-  createMockContent,
-  createMockConversation,
-  createMockConversationState,
-  createMockDatabase,
-  createMockDatabaseService,
-  createMockDbConnection,
-  createMockFact,
-  createMockHttpService,
-  createMockMedia,
-  createMockMemory,
-  createMockMemoryWithEmbedding,
-  createMockMessagingService,
-  createMockModelService,
-  createMockProviderResult,
-  createMockRuntime,
-  createMockService,
-  createMockServiceMap,
-  createMockState,
-  createMockStateWithActions,
-  createMockStateWithProvider,
-  createMockUserMessage,
-  createModelHandler,
-  createMultiAgentScenario,
-  createMultipleCharacters,
-  createPerformanceTest,
-  createPluginTest,
-  createPluginTestCharacter,
-  createPluginTestScenario,
-  createRichConversationCharacter,
-  createSpecializedModelProvider,
-  createTestAction,
-  createTestDatabase,
-  createTestEnvironment,
-  createTestEvaluator,
-  createTestModelProvider,
-  createTestProvider,
-  createTestRuntime,
-  createUnitTest,
-  mock,
-  registerMockServices,
+  scenarios,
   runIntegrationTest,
-  scenarios
+  registerMockServices,
+  mock,
+  createUnitTest,
+  createTestRuntime,
+  createTestProvider,
+  createTestModelProvider,
+  createTestEvaluator,
+  createTestEnvironment,
+  createTestDatabase,
+  createTestAction,
+  createSpecializedModelProvider,
+  createRichConversationCharacter,
+  createPluginTestScenario,
+  createPluginTestCharacter,
+  createPluginTest,
+  createPerformanceTest,
+  createMultipleCharacters,
+  createMultiAgentScenario,
+  createModelHandler,
+  createMockUserMessage,
+  createMockStateWithProvider,
+  createMockStateWithActions,
+  createMockState,
+  createMockServiceMap,
+  createMockService,
+  createMockRuntime,
+  createMockProviderResult,
+  createMockModelService,
+  createMockMessagingService,
+  createMockMemoryWithEmbedding,
+  createMockMemory,
+  createMockMedia,
+  createMockHttpService,
+  createMockFact,
+  createMockDbConnection,
+  createMockDatabaseService,
+  createMockDatabase,
+  createMockConversationState,
+  createMockConversation,
+  createMockContent,
+  createMockCharacter,
+  createMockCacheService,
+  createMockBlockchainService,
+  createMockAgentResponse,
+  createMockActionResult,
+  createMinimalMockCharacter,
+  createIntegrationTest,
+  createErrorTest,
+  UnitTestTemplate,
+  TestTemplate,
+  TestSuite,
+  TestScenarioBuilder,
+  TestModelProvider,
+  TestDatabaseManager,
+  TestDataGenerator,
+  RuntimeTestHarness,
+  PluginTestTemplate,
+  PerformanceTestTemplate,
+  IntegrationTestTemplate,
+  ErrorTestTemplate
 };
-//# sourceMappingURL=index.js.map
+
+//# debugId=E46556112309126564756E2164756E21
+//# sourceMappingURL=index.js.map