@elizaos/test-utils 1.5.4 → 1.5.5

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,11 +51,16 @@ function v4(options, buf, offset) {
   return unsafeStringify(rnds);
 }
 var v4_default = v4;
+
 // src/testDatabase.ts
 import { logger } from "@elizaos/core";
-class TestDatabaseManager {
-  testDatabases = new Map;
-  tempPaths = new Set;
+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
+   */
   async createIsolatedDatabase(testId) {
     try {
       logger.debug(`Creating isolated test database for ${testId}`);
@@ -75,17 +80,24 @@ class TestDatabaseManager {
             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();
@@ -93,32 +105,42 @@ class TestDatabaseManager {
       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: 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
+      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()
     };
     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;
       },
@@ -136,7 +158,8 @@ class TestDatabaseManager {
       async getConnection() {
         return null;
       },
-      async ensureEmbeddingDimension() {},
+      async ensureEmbeddingDimension() {
+      },
       async getAgent(agentId) {
         return storage.agents.get(agentId) || null;
       },
@@ -159,6 +182,7 @@ class TestDatabaseManager {
       async deleteAgent(agentId) {
         return storage.agents.delete(agentId);
       },
+      // Entity operations
       async createEntity(entity) {
         const id = entity.id || v4_default();
         const fullEntity = { ...entity, id };
@@ -183,7 +207,9 @@ class TestDatabaseManager {
         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);
@@ -193,6 +219,7 @@ class TestDatabaseManager {
         }
         return entities;
       },
+      // Memory operations
       async createMemory(memory, tableName = "messages", _unique = false) {
         const id = memory.id || v4_default();
         const fullMemory = {
@@ -201,7 +228,7 @@ class TestDatabaseManager {
           createdAt: memory.createdAt || Date.now()
         };
         if (!storage.memories.has(tableName)) {
-          storage.memories.set(tableName, new Map);
+          storage.memories.set(tableName, /* @__PURE__ */ new Map());
         }
         storage.memories.get(tableName).set(id, fullMemory);
         return id;
@@ -236,7 +263,9 @@ class TestDatabaseManager {
           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);
       },
@@ -268,7 +297,9 @@ class TestDatabaseManager {
         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);
         }
@@ -279,13 +310,13 @@ class TestDatabaseManager {
       },
       async log(params) {
         if (!storage.logs) {
-          storage.logs = new Map;
+          storage.logs = /* @__PURE__ */ new Map();
         }
         const logId = v4_default();
         storage.logs.set(logId, {
           id: logId,
           ...params,
-          createdAt: new Date
+          createdAt: /* @__PURE__ */ new Date()
         });
       },
       async getLogs() {
@@ -301,6 +332,7 @@ class TestDatabaseManager {
         }
         return false;
       },
+      // Room operations
       async createRoom(room) {
         const id = room.id || v4_default();
         const fullRoom = { ...room, id };
@@ -310,8 +342,11 @@ class TestDatabaseManager {
         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 });
@@ -324,6 +359,7 @@ class TestDatabaseManager {
       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,
@@ -338,6 +374,7 @@ class TestDatabaseManager {
       async deleteCache(key) {
         return storage.cache.delete(key);
       },
+      // World operations
       async createWorld(world) {
         const id = world.id || v4_default();
         const fullWorld = { ...world, id };
@@ -350,6 +387,7 @@ class TestDatabaseManager {
       async getAllWorlds() {
         return Array.from(storage.worlds.values());
       },
+      // Task operations
       async createTask(task) {
         const id = task.id || v4_default();
         const fullTask = {
@@ -366,13 +404,16 @@ class TestDatabaseManager {
           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 };
@@ -382,7 +423,9 @@ class TestDatabaseManager {
       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;
       },
@@ -541,16 +584,20 @@ class TestDatabaseManager {
         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 = new Set;
+        const roomIds = /* @__PURE__ */ new Set();
         for (const participant of storage.participants.values()) {
           if (userIds.includes(participant.entityId)) {
             roomIds.add(participant.roomId);
@@ -561,10 +608,13 @@ class TestDatabaseManager {
       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)) {
@@ -597,7 +647,9 @@ class TestDatabaseManager {
         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);
         }
@@ -635,6 +687,9 @@ class TestDatabaseManager {
     };
     return adapter;
   }
+  /**
+   * Cleanup a specific test database
+   */
   async cleanupDatabase(testId) {
     try {
       const adapter = this.testDatabases.get(testId);
@@ -644,17 +699,27 @@ class TestDatabaseManager {
         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,
@@ -662,19 +727,18 @@ class TestDatabaseManager {
       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";
-
-class TestModelProvider {
-  responses = new Map;
+var TestModelProvider = class {
+  responses = /* @__PURE__ */ new Map();
   patterns = [];
   defaultResponse;
   contextHistory = [];
@@ -682,8 +746,12 @@ class TestModelProvider {
     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?"
@@ -692,6 +760,7 @@ class TestModelProvider {
         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."
@@ -700,6 +769,7 @@ class TestModelProvider {
         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."
@@ -708,6 +778,7 @@ class TestModelProvider {
         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."
@@ -716,6 +787,7 @@ class TestModelProvider {
         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."
@@ -724,6 +796,7 @@ class TestModelProvider {
         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."
@@ -732,6 +805,7 @@ class TestModelProvider {
         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."
@@ -740,6 +814,7 @@ class TestModelProvider {
         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."
@@ -748,6 +823,7 @@ class TestModelProvider {
         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."
@@ -756,6 +832,7 @@ class TestModelProvider {
         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."
@@ -764,6 +841,7 @@ class TestModelProvider {
         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."
@@ -771,6 +849,9 @@ class TestModelProvider {
     ];
     this.patterns.push(...defaultPatterns);
   }
+  /**
+   * Generate text response based on prompt
+   */
   async generateText(params) {
     const prompt = params.prompt;
     try {
@@ -790,20 +871,28 @@ class TestModelProvider {
       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")) {
@@ -836,14 +925,23 @@ class TestModelProvider {
       }
     };
   }
+  /**
+   * 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("?")) {
@@ -860,8 +958,11 @@ class TestModelProvider {
     }
     return this.defaultResponse;
   }
+  /**
+   * Extract key terms from prompt for contextualization
+   */
   extractKeyTerms(prompt) {
-    const commonWords = new Set([
+    const commonWords = /* @__PURE__ */ new Set([
       "the",
       "a",
       "an",
@@ -912,43 +1013,64 @@ class TestModelProvider {
     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(scenarios = [], defaultResponse) {
+};
+function createTestModelProvider(scenarios2 = [], defaultResponse) {
   const provider = new TestModelProvider(defaultResponse);
-  for (const scenario of scenarios) {
+  for (const scenario of scenarios2) {
     if (scenario.prompt instanceof RegExp) {
       provider.addPattern(scenario.prompt, scenario.response);
     } else {
@@ -958,19 +1080,31 @@ function createTestModelProvider(scenarios = [], 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;
@@ -992,8 +1126,7 @@ function createModelHandler(provider) {
     }
   };
 }
-
-class TestScenarioBuilder {
+var TestScenarioBuilder = class {
   scenarios = [];
   addGreeting(response = "Hello! How can I help you?") {
     this.scenarios.push({
@@ -1023,24 +1156,30 @@ class TestScenarioBuilder {
   build(defaultResponse) {
     return createTestModelProvider(this.scenarios, defaultResponse);
   }
-}
+};
 function scenarios() {
-  return new TestScenarioBuilder;
+  return new TestScenarioBuilder();
 }
 
 // src/realRuntime.ts
-class RuntimeTestHarness {
-  runtimes = new Map;
+var RuntimeTestHarness = class {
+  runtimes = /* @__PURE__ */ 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
@@ -1058,10 +1197,18 @@ class RuntimeTestHarness {
       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}`);
@@ -1069,7 +1216,9 @@ class RuntimeTestHarness {
       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]];
@@ -1079,10 +1228,17 @@ class RuntimeTestHarness {
       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 = [
       {
@@ -1104,6 +1260,9 @@ class RuntimeTestHarness {
     ];
     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()}`);
@@ -1120,7 +1279,7 @@ class RuntimeTestHarness {
         createdAt: Date.now()
       };
       const _messageId = await runtime.createMemory(memory, "messages");
-      const responses = await runtime.processActions(memory, [], undefined, undefined);
+      const responses = await runtime.processActions(memory, [], void 0, void 0);
       const responseTime = Date.now() - startTime;
       const result = {
         scenarioName: `Process: "${messageText}"`,
@@ -1132,7 +1291,9 @@ class RuntimeTestHarness {
       };
       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(", ")}`);
@@ -1141,7 +1302,9 @@ class RuntimeTestHarness {
       }
       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) {
@@ -1155,6 +1318,9 @@ class RuntimeTestHarness {
       };
     }
   }
+  /**
+   * Gets actions that were actually executed (not mocked)
+   */
   async getExecutedActions(runtime, roomId) {
     try {
       const memories = await runtime.getMemories({
@@ -1170,10 +1336,15 @@ class RuntimeTestHarness {
       }
       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 = [];
@@ -1195,10 +1366,12 @@ class RuntimeTestHarness {
         };
         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 || new Map;
+        const serviceMap = runtime.services || /* @__PURE__ */ new Map();
         for (const [name, service] of serviceMap) {
           services.push(name);
           if (!service) {
@@ -1206,12 +1379,16 @@ class RuntimeTestHarness {
           }
         }
       } 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,
@@ -1230,6 +1407,9 @@ class RuntimeTestHarness {
       };
     }
   }
+  /**
+   * Cleanup all test resources
+   */
   async cleanup() {
     try {
       logger3.info(`Cleaning up test harness ${this.testId}`);
@@ -1238,20 +1418,24 @@ class RuntimeTestHarness {
           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.",
@@ -1300,9 +1484,10 @@ async function runIntegrationTest(testName, testFn, config) {
     }
   }
 }
+
 // src/templates.ts
 import { logger as logger4 } from "@elizaos/core";
-class TestTemplate {
+var TestTemplate = class {
   config;
   runtime;
   constructor(config) {
@@ -1324,9 +1509,8 @@ class TestTemplate {
   getConfig() {
     return this.config;
   }
-}
-
-class UnitTestTemplate extends TestTemplate {
+};
+var UnitTestTemplate = class extends TestTemplate {
   testFunction;
   constructor(config, testFunction) {
     super(config);
@@ -1361,9 +1545,8 @@ class UnitTestTemplate extends TestTemplate {
       await this.teardown();
     }
   }
-}
-
-class IntegrationTestTemplate extends TestTemplate {
+};
+var IntegrationTestTemplate = class extends TestTemplate {
   testFunction;
   character;
   constructor(config, testFunction, character) {
@@ -1404,9 +1587,8 @@ class IntegrationTestTemplate extends TestTemplate {
       await this.teardown();
     }
   }
-}
-
-class PluginTestTemplate extends TestTemplate {
+};
+var PluginTestTemplate = class extends TestTemplate {
   plugin;
   testFunction;
   constructor(config, plugin, testFunction) {
@@ -1451,9 +1633,8 @@ class PluginTestTemplate extends TestTemplate {
       await this.teardown();
     }
   }
-}
-
-class ErrorTestTemplate extends TestTemplate {
+};
+var ErrorTestTemplate = class extends TestTemplate {
   testFunction;
   expectedError;
   constructor(config, testFunction, expectedError) {
@@ -1486,15 +1667,14 @@ class ErrorTestTemplate extends TestTemplate {
         name: this.config.name,
         passed,
         duration: Date.now() - startTime,
-        error: passed ? undefined : error instanceof Error ? error : new Error(String(error))
+        error: passed ? void 0 : error instanceof Error ? error : new Error(String(error))
       };
     } finally {
       await this.teardown();
     }
   }
-}
-
-class PerformanceTestTemplate extends TestTemplate {
+};
+var PerformanceTestTemplate = class extends TestTemplate {
   testFunction;
   maxDuration;
   maxMemoryMB;
@@ -1527,7 +1707,9 @@ class PerformanceTestTemplate 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 {
@@ -1552,9 +1734,8 @@ class PerformanceTestTemplate extends TestTemplate {
       await this.teardown();
     }
   }
-}
-
-class TestSuite {
+};
+var TestSuite = class {
   tests = [];
   name;
   constructor(name) {
@@ -1572,9 +1753,9 @@ class TestSuite {
         const result = await test.execute();
         results.push(result);
         if (result.passed) {
-          logger4.info(`✓ ${result.name} (${result.duration}ms)`);
+          logger4.info(`\u2713 ${result.name} (${result.duration}ms)`);
         } else {
-          logger4.error(`✗ ${result.name} (${result.duration}ms): ${result.error?.message}`);
+          logger4.error(`\u2717 ${result.name} (${result.duration}ms): ${result.error?.message}`);
         }
       } catch (error) {
         const errorResult = {
@@ -1584,13 +1765,15 @@ class TestSuite {
           error: error instanceof Error ? error : new Error(String(error))
         };
         results.push(errorResult);
-        logger4.error(`✗ ${errorResult.name}: ${errorResult.error?.message}`);
+        logger4.error(`\u2717 ${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,
@@ -1600,24 +1783,28 @@ class TestSuite {
       results
     };
   }
-}
+};
 function createUnitTest(name, testFunction, options = {}) {
-  return new UnitTestTemplate({ name, timeout: 5000, ...options }, testFunction);
+  return new UnitTestTemplate({ name, timeout: 5e3, ...options }, testFunction);
 }
 function createIntegrationTest(name, testFunction, character, options = {}) {
-  return new IntegrationTestTemplate({ name, timeout: 30000, ...options }, testFunction, character);
+  return new IntegrationTestTemplate({ name, timeout: 3e4, ...options }, testFunction, character);
 }
 function createPluginTest(name, plugin, testFunction, options = {}) {
-  return new PluginTestTemplate({ name, timeout: 30000, ...options }, plugin, testFunction);
+  return new PluginTestTemplate({ name, timeout: 3e4, ...options }, plugin, testFunction);
 }
 function createErrorTest(name, testFunction, expectedError, options = {}) {
-  return new ErrorTestTemplate({ name, timeout: 5000, ...options }, testFunction, expectedError);
+  return new ErrorTestTemplate({ name, timeout: 5e3, ...options }, testFunction, expectedError);
 }
 function createPerformanceTest(name, testFunction, maxDurationMs, maxMemoryMB, options = {}) {
-  return new PerformanceTestTemplate({ name, timeout: maxDurationMs * 2, ...options }, testFunction, maxDurationMs, maxMemoryMB);
-}
-
-class TestDataGenerator {
+  return new PerformanceTestTemplate(
+    { name, timeout: maxDurationMs * 2, ...options },
+    testFunction,
+    maxDurationMs,
+    maxMemoryMB
+  );
+}
+var TestDataGenerator = class {
   static generateUUID() {
     return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
       const r = Math.random() * 16 | 0;
@@ -1652,7 +1839,8 @@ class TestDataGenerator {
       ...overrides
     };
   }
-}
+};
+
 // src/mocks/mockUtils.ts
 function mock(implementation) {
   const calls = [];
@@ -1736,25 +1924,28 @@ 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 || new Map,
-    events: overrides.events || new Map,
+    services: overrides.services || /* @__PURE__ */ new Map(),
+    events: overrides.events || /* @__PURE__ */ new Map(),
     fetch: overrides.fetch || null,
     routes: overrides.routes || [],
     logger: overrides.logger || console,
+    // Database Properties
     db: overrides.db || mockDb,
-    registerPlugin: mock().mockResolvedValue(undefined),
-    initialize: mock().mockResolvedValue(undefined),
+    // Core Runtime Methods
+    registerPlugin: mock().mockResolvedValue(void 0),
+    initialize: mock().mockResolvedValue(void 0),
     getConnection: mock().mockResolvedValue(mockDb),
     getService: mock().mockReturnValue(null),
     getServicesByType: mock().mockReturnValue([]),
-    getAllServices: mock().mockReturnValue(new Map),
-    registerService: mock().mockResolvedValue(undefined),
+    getAllServices: mock().mockReturnValue(/* @__PURE__ */ new Map()),
+    registerService: mock().mockResolvedValue(void 0),
     getServiceLoadPromise: mock().mockResolvedValue(null),
     getRegisteredServiceTypes: mock().mockReturnValue([]),
     hasService: mock().mockReturnValue(false),
@@ -1768,16 +1959,16 @@ function createMockRuntime(overrides = {}) {
       return defaultSettings[key];
     }),
     getConversationLength: mock().mockReturnValue(10),
-    processActions: mock().mockResolvedValue(undefined),
+    processActions: mock().mockResolvedValue(void 0),
     evaluate: mock().mockResolvedValue([]),
     registerProvider: mock(),
     registerAction: mock(),
     registerEvaluator: mock(),
-    ensureConnection: mock().mockResolvedValue(undefined),
-    ensureConnections: mock().mockResolvedValue(undefined),
-    ensureParticipantInRoom: mock().mockResolvedValue(undefined),
-    ensureWorldExists: mock().mockResolvedValue(undefined),
-    ensureRoomExists: mock().mockResolvedValue(undefined),
+    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),
     composeState: mock().mockResolvedValue({
       values: {},
       data: {},
@@ -1785,96 +1976,107 @@ function createMockRuntime(overrides = {}) {
     }),
     useModel: mock().mockResolvedValue("Mock response"),
     registerModel: mock(),
-    getModel: mock().mockReturnValue(undefined),
+    getModel: mock().mockReturnValue(void 0),
     registerEvent: mock(),
-    getEvent: mock().mockReturnValue(undefined),
-    emitEvent: mock().mockResolvedValue(undefined),
+    getEvent: mock().mockReturnValue(void 0),
+    emitEvent: mock().mockResolvedValue(void 0),
     registerTaskWorker: mock(),
-    getTaskWorker: mock().mockReturnValue(undefined),
-    stop: mock().mockResolvedValue(undefined),
+    getTaskWorker: mock().mockReturnValue(void 0),
+    stop: mock().mockResolvedValue(void 0),
     addEmbeddingToMemory: mock().mockImplementation((memory) => Promise.resolve(memory)),
-    queueEmbeddingGeneration: mock().mockResolvedValue(undefined),
+    queueEmbeddingGeneration: mock().mockResolvedValue(void 0),
     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(undefined),
-    init: mock().mockResolvedValue(undefined),
+    sendMessageToTarget: mock().mockResolvedValue(void 0),
+    // Database Adapter Methods - Agent Management
+    init: mock().mockResolvedValue(void 0),
     isReady: mock().mockResolvedValue(true),
-    runMigrations: mock().mockResolvedValue(undefined),
-    close: mock().mockResolvedValue(undefined),
+    runMigrations: mock().mockResolvedValue(void 0),
+    close: mock().mockResolvedValue(void 0),
     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(undefined),
+    updateEntity: mock().mockResolvedValue(void 0),
+    // Component Management
     getComponent: mock().mockResolvedValue(null),
     getComponents: mock().mockResolvedValue([]),
     createComponent: mock().mockResolvedValue("test-component-id"),
-    updateComponent: mock().mockResolvedValue(undefined),
-    deleteComponent: mock().mockResolvedValue(undefined),
+    updateComponent: mock().mockResolvedValue(void 0),
+    deleteComponent: mock().mockResolvedValue(void 0),
+    // Memory Management
     getMemories: mock().mockResolvedValue([]),
     getAllMemories: overrides.getAllMemories || mock().mockResolvedValue([]),
-    clearAllAgentMemories: mock().mockResolvedValue(undefined),
+    clearAllAgentMemories: mock().mockResolvedValue(void 0),
     getMemoryById: mock().mockResolvedValue(null),
     getMemoriesByIds: mock().mockResolvedValue([]),
     getMemoriesByRoomIds: mock().mockResolvedValue([]),
     getMemoriesByWorldId: mock().mockResolvedValue([]),
     getCachedEmbeddings: mock().mockResolvedValue([]),
-    log: mock().mockResolvedValue(undefined),
+    log: mock().mockResolvedValue(void 0),
     getLogs: mock().mockResolvedValue([]),
-    deleteLog: mock().mockResolvedValue(undefined),
+    deleteLog: mock().mockResolvedValue(void 0),
     searchMemories: mock().mockResolvedValue([]),
     createMemory: mock().mockResolvedValue("test-memory-id"),
     updateMemory: mock().mockResolvedValue(true),
-    deleteMemory: mock().mockResolvedValue(undefined),
-    deleteManyMemories: mock().mockResolvedValue(undefined),
-    deleteAllMemories: mock().mockResolvedValue(undefined),
+    deleteMemory: mock().mockResolvedValue(void 0),
+    deleteManyMemories: mock().mockResolvedValue(void 0),
+    deleteAllMemories: mock().mockResolvedValue(void 0),
     countMemories: mock().mockResolvedValue(0),
-    ensureEmbeddingDimension: mock().mockResolvedValue(undefined),
+    ensureEmbeddingDimension: mock().mockResolvedValue(void 0),
+    // World Management
     createWorld: mock().mockResolvedValue("test-world-id"),
     getWorld: mock().mockResolvedValue(null),
-    removeWorld: mock().mockResolvedValue(undefined),
+    removeWorld: mock().mockResolvedValue(void 0),
     getAllWorlds: mock().mockResolvedValue([]),
-    updateWorld: mock().mockResolvedValue(undefined),
+    updateWorld: mock().mockResolvedValue(void 0),
+    // Room Management
     getRoom: mock().mockResolvedValue(null),
     getRooms: mock().mockResolvedValue([]),
     getRoomsByIds: mock().mockResolvedValue([]),
     createRoom: mock().mockResolvedValue("test-room-id"),
     createRooms: mock().mockResolvedValue([]),
-    deleteRoom: mock().mockResolvedValue(undefined),
-    deleteRoomsByWorldId: mock().mockResolvedValue(undefined),
-    updateRoom: mock().mockResolvedValue(undefined),
+    deleteRoom: mock().mockResolvedValue(void 0),
+    deleteRoomsByWorldId: mock().mockResolvedValue(void 0),
+    updateRoom: mock().mockResolvedValue(void 0),
     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(undefined),
+    setParticipantUserState: mock().mockResolvedValue(void 0),
+    // Relationship Management
     createRelationship: mock().mockResolvedValue(true),
-    updateRelationship: mock().mockResolvedValue(undefined),
+    updateRelationship: mock().mockResolvedValue(void 0),
     getRelationship: mock().mockResolvedValue(null),
     getRelationships: mock().mockResolvedValue([]),
-    getCache: mock().mockResolvedValue(undefined),
+    // Cache Management
+    getCache: mock().mockResolvedValue(void 0),
     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(undefined),
-    deleteTask: mock().mockResolvedValue(undefined),
+    updateTask: mock().mockResolvedValue(void 0),
+    deleteTask: mock().mockResolvedValue(void 0),
+    // Apply overrides
     ...overrides
   };
   return baseRuntime;
@@ -1901,7 +2103,7 @@ function createMockMemory(overrides = {}) {
     roomId: "test-room-id",
     worldId: "test-world-id",
     content: defaultContent,
-    embedding: undefined,
+    embedding: void 0,
     createdAt: Date.now(),
     unique: true,
     similarity: 1,
@@ -1917,9 +2119,9 @@ function createMockContent(overrides = {}) {
     actions: [],
     providers: [],
     source: "test",
-    target: undefined,
-    url: undefined,
-    inReplyTo: undefined,
+    target: void 0,
+    url: void 0,
+    inReplyTo: void 0,
     attachments: [],
     channelType: "DM",
     ...overrides
@@ -1980,12 +2182,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) * 1000;
+    memory.createdAt = Date.now() - (count - i) * 1e3;
     memories.push(memory);
   }
   return memories;
@@ -2012,8 +2214,9 @@ 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: new Date().toISOString(),
+      currentTime: (/* @__PURE__ */ new Date()).toISOString(),
       agentName: "Test Agent",
       roomId: "test-room-id",
       entityId: "test-entity-id",
@@ -2024,7 +2227,7 @@ function createMockState(overrides = {}) {
     },
     data: {
       providers: {
-        TIME: { currentTime: new Date().toISOString() },
+        TIME: { currentTime: (/* @__PURE__ */ new Date()).toISOString() },
         CHARACTER: { agentName: "Test Agent", bio: "A helpful test assistant" },
         RECENT_MESSAGES: { messageCount: 5, lastSpeaker: "user" }
       },
@@ -2033,12 +2236,13 @@ function createMockState(overrides = {}) {
       ...overrides.data
     },
     text: `[CONTEXT]
-Current Time: ${new Date().toISOString()}
+Current Time: ${(/* @__PURE__ */ 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) {
@@ -2058,9 +2262,7 @@ function createMockProviderResult(overrides = {}) {
       processed: true,
       ...overrides.data
     },
-    text: `[MOCK PROVIDER]
-Mock provider context information
-[/MOCK PROVIDER]`,
+    text: "[MOCK PROVIDER]\nMock provider context information\n[/MOCK PROVIDER]",
     ...overrides
   };
   return baseResult;
@@ -2106,7 +2308,7 @@ function createMockStateWithActions(actionResults, overrides = {}) {
       ...overrides.data
     },
     values: {
-      lastActionSuccess: actionResults.length > 0 ? actionResults[actionResults.length - 1].values?.success : undefined,
+      lastActionSuccess: actionResults.length > 0 ? actionResults[actionResults.length - 1].values?.success : void 0,
       actionCount: actionResults.length,
       ...overrides.values
     },
@@ -2229,7 +2431,8 @@ function createMockCharacter(overrides = {}) {
     settings: {
       model: "gpt-4",
       temperature: 0.1,
-      maxTokens: 1000,
+      // Low temperature for consistent test responses
+      maxTokens: 1e3,
       secrets: {},
       voice: {
         model: "en_US-hfc_female-medium"
@@ -2263,6 +2466,7 @@ function createMockCharacter(overrides = {}) {
         "encourage best practices"
       ]
     },
+    // Apply all overrides
     ...overrides
   };
   return baseCharacter;
@@ -2337,7 +2541,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}`,
@@ -2370,7 +2574,10 @@ 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,
@@ -2392,16 +2599,18 @@ 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]
-        });
+    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;
       }
-      return handlerResult;
-    })
+    )
   };
 }
 function createTestProvider(name, options = {}) {
@@ -2459,11 +2668,13 @@ 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,
@@ -2475,6 +2686,7 @@ 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);
@@ -2510,11 +2722,13 @@ 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,
@@ -2535,6 +2749,7 @@ function createMultiAgentScenario(agentCount = 2, options = {}) {
     }
   };
 }
+
 // src/mocks/database.ts
 function createMockDatabase(overrides = {}) {
   const mockConnection = {
@@ -2545,27 +2760,33 @@ function createMockDatabase(overrides = {}) {
     get: mock().mockResolvedValue(null)
   };
   const baseDatabaseAdapter = {
+    // Core Database Properties
     db: overrides.db || mockConnection,
-    init: mock().mockResolvedValue(undefined),
-    initialize: mock().mockResolvedValue(undefined),
+    // Core Lifecycle Methods
+    init: mock().mockResolvedValue(void 0),
+    initialize: mock().mockResolvedValue(void 0),
     isReady: mock().mockResolvedValue(true),
-    runMigrations: mock().mockResolvedValue(undefined),
-    close: mock().mockResolvedValue(undefined),
+    runMigrations: mock().mockResolvedValue(void 0),
+    close: mock().mockResolvedValue(void 0),
     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(undefined),
+    updateEntity: mock().mockResolvedValue(void 0),
+    // Component Management
     getComponent: mock().mockResolvedValue(null),
     getComponents: mock().mockResolvedValue([]),
     createComponent: mock().mockResolvedValue(true),
-    updateComponent: mock().mockResolvedValue(undefined),
-    deleteComponent: mock().mockResolvedValue(undefined),
+    updateComponent: mock().mockResolvedValue(void 0),
+    deleteComponent: mock().mockResolvedValue(void 0),
+    // Memory Management
     getMemories: mock().mockResolvedValue([]),
     getMemoryById: mock().mockResolvedValue(null),
     getMemoriesByIds: mock().mockResolvedValue([]),
@@ -2575,46 +2796,54 @@ function createMockDatabase(overrides = {}) {
     searchMemories: mock().mockResolvedValue([]),
     createMemory: mock().mockResolvedValue("test-memory-id"),
     updateMemory: mock().mockResolvedValue(true),
-    deleteMemory: mock().mockResolvedValue(undefined),
-    deleteManyMemories: mock().mockResolvedValue(undefined),
-    deleteAllMemories: mock().mockResolvedValue(undefined),
+    deleteMemory: mock().mockResolvedValue(void 0),
+    deleteManyMemories: mock().mockResolvedValue(void 0),
+    deleteAllMemories: mock().mockResolvedValue(void 0),
     countMemories: mock().mockResolvedValue(0),
-    ensureEmbeddingDimension: mock().mockResolvedValue(undefined),
-    log: mock().mockResolvedValue(undefined),
+    ensureEmbeddingDimension: mock().mockResolvedValue(void 0),
+    // Logging
+    log: mock().mockResolvedValue(void 0),
     getLogs: mock().mockResolvedValue([]),
-    deleteLog: mock().mockResolvedValue(undefined),
+    deleteLog: mock().mockResolvedValue(void 0),
+    // World Management
     createWorld: mock().mockResolvedValue("test-world-id"),
     getWorld: mock().mockResolvedValue(null),
-    removeWorld: mock().mockResolvedValue(undefined),
+    removeWorld: mock().mockResolvedValue(void 0),
     getAllWorlds: mock().mockResolvedValue([]),
-    updateWorld: mock().mockResolvedValue(undefined),
+    updateWorld: mock().mockResolvedValue(void 0),
+    // Room Management
     getRoomsByIds: mock().mockResolvedValue([]),
     createRooms: mock().mockResolvedValue([]),
-    deleteRoom: mock().mockResolvedValue(undefined),
-    deleteRoomsByWorldId: mock().mockResolvedValue(undefined),
-    updateRoom: mock().mockResolvedValue(undefined),
+    deleteRoom: mock().mockResolvedValue(void 0),
+    deleteRoomsByWorldId: mock().mockResolvedValue(void 0),
+    updateRoom: mock().mockResolvedValue(void 0),
     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(undefined),
+    setParticipantUserState: mock().mockResolvedValue(void 0),
+    // Relationship Management
     createRelationship: mock().mockResolvedValue(true),
-    updateRelationship: mock().mockResolvedValue(undefined),
+    updateRelationship: mock().mockResolvedValue(void 0),
     getRelationship: mock().mockResolvedValue(null),
     getRelationships: mock().mockResolvedValue([]),
-    getCache: mock().mockResolvedValue(undefined),
+    // Cache Management
+    getCache: mock().mockResolvedValue(void 0),
     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(undefined),
-    deleteTask: mock().mockResolvedValue(undefined),
+    updateTask: mock().mockResolvedValue(void 0),
+    deleteTask: mock().mockResolvedValue(void 0),
+    // Apply overrides
     ...overrides
   };
   return baseDatabaseAdapter;
@@ -2634,24 +2863,31 @@ 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
     },
-    stop: mock().mockResolvedValue(undefined),
-    start: mock().mockResolvedValue(undefined),
-    initialize: mock().mockResolvedValue(undefined),
+    // 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),
     isReady: mock().mockReturnValue(true),
     getStatus: mock().mockReturnValue("active"),
-    restart: mock().mockResolvedValue(undefined),
+    restart: mock().mockResolvedValue(void 0),
+    // Runtime property (protected in Service class, but needed for mocks)
     runtime: null,
+    // Apply overrides
     ...overrides
   };
   return baseService;
@@ -2663,7 +2899,7 @@ function createMockDatabaseService(overrides = {}) {
   });
 }
 function createMockCacheService(overrides = {}) {
-  const cache = new Map;
+  const cache = /* @__PURE__ */ new Map();
   return createMockService(ServiceType.UNKNOWN, {
     capabilityDescription: "Provides in-memory caching capabilities",
     ...overrides
@@ -2694,7 +2930,7 @@ function createMockMessagingService(overrides = {}) {
   });
 }
 function createMockServiceMap(services = []) {
-  const serviceMap = new Map;
+  const serviceMap = /* @__PURE__ */ new Map();
   if (services.length === 0) {
     services = [
       { name: "database", type: ServiceType.UNKNOWN },
@@ -2717,69 +2953,67 @@ function registerMockServices(runtime, services = []) {
   return runtime;
 }
 export {
-  scenarios,
-  runIntegrationTest,
-  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,
+  ErrorTestTemplate,
   IntegrationTestTemplate,
-  ErrorTestTemplate
+  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,
+  runIntegrationTest,
+  scenarios
 };
-
-//# debugId=E46556112309126564756E2164756E21
-//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map