@elizaos/core 2.0.0-alpha.53 → 2.0.0-alpha.55

package/dist/node/index.node.js

@@ -32304,11 +32304,15 @@ function sealAdze(base) {
   }
   if (raw && !metaBase.hostname) {
     let hostname = "unknown";
-    if (typeof process !== "undefined" && process.platform) {
-      const os = __require("node:os");
-      hostname = os.hostname();
-    } else if (typeof window !== "undefined" && window.location) {
-      hostname = window.location.hostname || "browser";
+    try {
+      if (typeof process !== "undefined" && process.platform) {
+        const os = __require("node:os");
+        hostname = os.hostname();
+      } else if (typeof window !== "undefined" && window.location) {
+        hostname = window.location.hostname || "browser";
+      }
+    } catch {
+      hostname = "unknown";
     }
     metaBase.hostname = hostname;
   }
@@ -37331,7 +37335,7 @@ class Service {
     throw new Error("Service.start() must be implemented by subclass");
   }
 }
-function getTypedService(runtime, serviceType) {
+async function getTypedService(runtime, serviceType) {
   return runtime.getService(serviceType);
 }
 function createServiceError(error, code = "UNKNOWN_ERROR") {
@@ -68504,7 +68508,7 @@ var init_long_term_extraction = __esm(() => {
         return false;
       if (!message2.content?.text)
         return false;
-      const memoryService = runtime2.getService("memory");
+      const memoryService = await runtime2.getService("memory");
       if (!memoryService)
         return false;
       const config2 = memoryService.getConfig();
@@ -68520,7 +68524,7 @@ var init_long_term_extraction = __esm(() => {
       return memoryService.shouldRunExtraction(message2.entityId, message2.roomId, currentMessageCount);
     },
     handler: async (runtime2, message2) => {
-      const memoryService = runtime2.getService("memory");
+      const memoryService = await runtime2.getService("memory");
       if (!memoryService) {
         logger.error({ src: "evaluator:memory" }, "MemoryService not found");
         return;
@@ -68644,7 +68648,7 @@ var init_summarization = __esm(() => {
     validate: async (runtime2, message2) => {
       if (!message2.content?.text)
         return false;
-      const memoryService = runtime2.getService("memory");
+      const memoryService = await runtime2.getService("memory");
       if (!memoryService)
         return false;
       const config2 = memoryService.getConfig();
@@ -68657,7 +68661,7 @@ var init_summarization = __esm(() => {
       return newDialogueCount >= config2.shortTermSummarizationInterval;
     },
     handler: async (runtime2, message2) => {
-      const memoryService = runtime2.getService("memory");
+      const memoryService = await runtime2.getService("memory");
       if (!memoryService) {
         logger.error({ src: "evaluator:memory" }, "MemoryService not found");
         return;
@@ -68785,7 +68789,7 @@ var init_context_summary = __esm(() => {
     position: 96,
     get: async (runtime2, message2, _state2) => {
       try {
-        const memoryService = runtime2.getService("memory");
+        const memoryService = await runtime2.getService("memory");
         const { roomId } = message2;
         if (!memoryService) {
           return {
@@ -68847,7 +68851,7 @@ var init_long_term_memory = __esm(() => {
     position: 50,
     get: async (runtime2, message2, _state2) => {
       try {
-        const memoryService = runtime2.getService("memory");
+        const memoryService = await runtime2.getService("memory");
         if (!memoryService) {
           return {
             data: { memoryCount: 0 },
@@ -68965,7 +68969,7 @@ var init_memory_service = __esm(() => {
     }
     async initialize(runtime2) {
       this.runtime = runtime2;
-      const provider = runtime2.getService("memoryStorage");
+      const provider = await runtime2.getService("memoryStorage");
       if (!provider) {
         logger.warn({ src: "service:memory", agentId: runtime2.agentId }, "No MemoryStorageProvider found — long-term memory and session summaries disabled. " + "Register a memoryStorage service from your database plugin to enable them.");
       }
@@ -71622,7 +71626,7 @@ var sendToAdminAction = {
     ]
   ],
   validate: async (runtime2, message2) => {
-    const autonomyService = runtime2.getService(AUTONOMY_SERVICE_TYPE);
+    const autonomyService = await runtime2.getService(AUTONOMY_SERVICE_TYPE);
     if (!autonomyService) {
       return false;
     }
@@ -71641,7 +71645,7 @@ var sendToAdminAction = {
     return ADMIN_KEYWORDS.some((keyword) => text.includes(keyword));
   },
   handler: async (runtime2, message2, _state2, _options, callback) => {
-    const autonomyService = runtime2.getService(AUTONOMY_SERVICE_TYPE);
+    const autonomyService = await runtime2.getService(AUTONOMY_SERVICE_TYPE);
     if (!autonomyService) {
       return {
         success: false,
@@ -71734,7 +71738,7 @@ var adminChatProvider = {
   name: "ADMIN_CHAT_HISTORY",
   description: "Provides recent conversation history with the admin user for autonomous context",
   get: async (runtime2, message2, _state2) => {
-    const autonomyService = runtime2.getService(AUTONOMY_SERVICE_TYPE);
+    const autonomyService = await runtime2.getService(AUTONOMY_SERVICE_TYPE);
     if (!autonomyService) {
       return { text: "", data: {} };
     }
@@ -71817,7 +71821,7 @@ var autonomyStatusProvider = {
   name: "AUTONOMY_STATUS",
   description: "Provides current autonomy status for agent awareness in conversations",
   get: async (runtime2, message2, _state2) => {
-    const autonomyService = runtime2.getService(AUTONOMY_SERVICE_TYPE);
+    const autonomyService = await runtime2.getService(AUTONOMY_SERVICE_TYPE);
     if (!autonomyService) {
       return { text: "", data: {} };
     }
@@ -71858,15 +71862,15 @@ Thinking interval: ${intervalUnit}
   }
 };
 // src/autonomy/routes.ts
-function getAutonomyService(runtime2) {
-  return runtime2.getService(AUTONOMY_SERVICE_TYPE) || runtime2.getService("autonomy");
+async function getAutonomyService(runtime2) {
+  return await runtime2.getService(AUTONOMY_SERVICE_TYPE) || await runtime2.getService("autonomy");
 }
 var autonomyRoutes = [
   {
     path: "/autonomy/status",
     type: "GET",
     handler: async (_req, res, runtime2) => {
-      const autonomyService = getAutonomyService(runtime2);
+      const autonomyService = await getAutonomyService(runtime2);
       if (!autonomyService) {
         res.status(503).json({
           error: "Autonomy service not available"
@@ -71892,7 +71896,7 @@ var autonomyRoutes = [
     path: "/autonomy/enable",
     type: "POST",
     handler: async (_req, res, runtime2) => {
-      const autonomyService = getAutonomyService(runtime2);
+      const autonomyService = await getAutonomyService(runtime2);
       if (!autonomyService) {
         res.status(503).json({
           success: false,
@@ -71917,7 +71921,7 @@ var autonomyRoutes = [
     path: "/autonomy/disable",
     type: "POST",
     handler: async (_req, res, runtime2) => {
-      const autonomyService = getAutonomyService(runtime2);
+      const autonomyService = await getAutonomyService(runtime2);
       if (!autonomyService) {
         res.status(503).json({
           success: false,
@@ -71942,7 +71946,7 @@ var autonomyRoutes = [
     path: "/autonomy/toggle",
     type: "POST",
     handler: async (_req, res, runtime2) => {
-      const autonomyService = getAutonomyService(runtime2);
+      const autonomyService = await getAutonomyService(runtime2);
       if (!autonomyService) {
         res.status(503).json({
           success: false,
@@ -71972,7 +71976,7 @@ var autonomyRoutes = [
     path: "/autonomy/interval",
     type: "POST",
     handler: async (req, res, runtime2) => {
-      const autonomyService = getAutonomyService(runtime2);
+      const autonomyService = await getAutonomyService(runtime2);
       if (!autonomyService) {
         res.status(503).json({
           success: false,
@@ -72823,7 +72827,7 @@ class TaskService extends Service {
     };
   }
   static async stop(runtime2) {
-    const service3 = runtime2.getService(ServiceType2.TASK);
+    const service3 = await runtime2.getService(ServiceType2.TASK);
     if (service3) {
       await service3.stop();
     }
@@ -75384,7 +75388,7 @@ var addContactAction = {
   similes: spec18.similes ? [...spec18.similes] : [],
   examples: spec18.examples ?? [],
   validate: async (runtime2, message2, _state2) => {
-    const rolodexService = runtime2.getService("rolodex");
+    const rolodexService = await runtime2.getService("rolodex");
     if (!rolodexService) {
       logger.warn("[AddContact] RolodexService not available");
       return false;
@@ -75395,7 +75399,7 @@ var addContactAction = {
     return ADD_KEYWORDS.some((keyword) => messageText.includes(keyword));
   },
   handler: async (runtime2, message2, state2, _options, callback) => {
-    const rolodexService = runtime2.getService("rolodex");
+    const rolodexService = await runtime2.getService("rolodex");
     if (!rolodexService) {
       throw new Error("RolodexService not available");
     }
@@ -75943,7 +75947,7 @@ var removeContactAction = {
   description: spec22.description,
   examples: spec22.examples ?? [],
   validate: async (runtime2, message2, _state2) => {
-    const hasService = !!runtime2.getService("rolodex");
+    const hasService = !!await runtime2.getService("rolodex");
     const text = message2.content.text;
     if (!text)
       return false;
@@ -75952,7 +75956,7 @@ var removeContactAction = {
   },
   handler: async (runtime2, message2, state2, _options, callback) => {
     try {
-      const rolodexService = runtime2.getService("rolodex");
+      const rolodexService = await runtime2.getService("rolodex");
       if (!rolodexService) {
         throw new Error("RolodexService not available");
       }
@@ -76304,8 +76308,8 @@ var scheduleFollowUpAction = {
   similes: spec24.similes ? [...spec24.similes] : [],
   examples: spec24.examples ?? [],
   validate: async (runtime2, message2, _state2) => {
-    const rolodexService = runtime2.getService("rolodex");
-    const followUpService = runtime2.getService("follow_up");
+    const rolodexService = await runtime2.getService("rolodex");
+    const followUpService = await runtime2.getService("follow_up");
     if (!rolodexService || !followUpService) {
       logger.warn("[ScheduleFollowUp] Required services not available");
       return false;
@@ -76316,8 +76320,8 @@ var scheduleFollowUpAction = {
     return FOLLOW_UP_KEYWORDS.some((keyword) => messageText.includes(keyword));
   },
   handler: async (runtime2, message2, state2, _options, callback) => {
-    const rolodexService = runtime2.getService("rolodex");
-    const followUpService = runtime2.getService("follow_up");
+    const rolodexService = await runtime2.getService("rolodex");
+    const followUpService = await runtime2.getService("follow_up");
     if (!rolodexService || !followUpService) {
       throw new Error("Required services not available");
     }
@@ -76427,7 +76431,7 @@ var searchContactsAction = {
   similes: spec25.similes ? [...spec25.similes] : [],
   examples: spec25.examples ?? [],
   validate: async (runtime2, message2, _state2) => {
-    const rolodexService = runtime2.getService("rolodex");
+    const rolodexService = await runtime2.getService("rolodex");
     if (!rolodexService) {
       logger.warn("[SearchContacts] RolodexService not available");
       return false;
@@ -76438,7 +76442,7 @@ var searchContactsAction = {
     return SEARCH_KEYWORDS.some((keyword) => messageText.includes(keyword));
   },
   handler: async (runtime2, message2, state2, _options, callback) => {
-    const rolodexService = runtime2.getService("rolodex");
+    const rolodexService = await runtime2.getService("rolodex");
     if (!rolodexService) {
       throw new Error("RolodexService not available");
     }
@@ -76812,7 +76816,7 @@ var sendMessageAction = {
           success: false
         };
       }
-      const service3 = runtime2.getService(source);
+      const service3 = await runtime2.getService(source);
       const sendDirectMessage = service3?.sendDirectMessage;
       if (!sendDirectMessage) {
         await callback({
@@ -76908,7 +76912,7 @@ var sendMessageAction = {
           success: false
         };
       }
-      const service3 = runtime2.getService(source);
+      const service3 = await runtime2.getService(source);
       const sendRoomMessage = service3?.sendRoomMessage;
       if (!sendRoomMessage) {
         await callback({
@@ -77441,10 +77445,11 @@ function isEncryptedV2(value) {
   }
 }
 function getSalt() {
-  const currentEnvSalt = typeof process !== "undefined" && process.env ? process.env.SECRET_SALT ?? "secretsalt" : getEnv3("SECRET_SALT", "secretsalt") || "secretsalt";
-  const nodeEnv = typeof process !== "undefined" && process.env ? "development".toLowerCase() : (getEnv3("NODE_ENV", "") || "").toLowerCase();
+  getEnvironment().clearCache();
+  const currentEnvSalt = getEnv3("SECRET_SALT", "secretsalt") || "secretsalt";
+  const nodeEnv = (getEnv3("NODE_ENV", "") || "").toLowerCase();
   const isProduction = nodeEnv === "production";
-  const allowDefaultSaltRaw = typeof process !== "undefined" && process.env ? process.env.ELIZA_ALLOW_DEFAULT_SECRET_SALT ?? "" : getEnv3("ELIZA_ALLOW_DEFAULT_SECRET_SALT", "") || "";
+  const allowDefaultSaltRaw = getEnv3("ELIZA_ALLOW_DEFAULT_SECRET_SALT", "") || "";
   const allowDefaultSalt = allowDefaultSaltRaw.toLowerCase() === "true";
   const now = Date.now();
   if (saltCache !== null) {
@@ -78653,7 +78658,7 @@ var updateContactAction = {
   description: spec30.description,
   examples: spec30.examples ?? [],
   validate: async (runtime2, message2, _state2) => {
-    const hasService = !!runtime2.getService("rolodex");
+    const hasService = !!await runtime2.getService("rolodex");
     const text = message2.content.text;
     if (!text)
       return false;
@@ -78662,7 +78667,7 @@ var updateContactAction = {
   },
   handler: async (runtime2, message2, state2, _options, callback) => {
     try {
-      const rolodexService = runtime2.getService("rolodex");
+      const rolodexService = await runtime2.getService("rolodex");
       if (!rolodexService) {
         throw new Error("RolodexService not available");
       }
@@ -79320,7 +79325,7 @@ var relationshipExtractionEvaluator = {
     return !!(message2.content?.text && message2.content.text.length > 0);
   },
   handler: async (runtime2, message2, _state2) => {
-    const rolodexService = runtime2.getService("rolodex");
+    const rolodexService = await runtime2.getService("rolodex");
     if (!rolodexService) {
       logger.warn("[RelationshipExtraction] RolodexService not available");
       return;
@@ -79881,7 +79886,7 @@ var contactsProvider = {
   name: spec34.name,
   description: spec34.description,
   get: async (runtime2, _message, _state2) => {
-    const rolodexService = runtime2.getService("rolodex");
+    const rolodexService = await runtime2.getService("rolodex");
     if (!rolodexService) {
       runtime2.logger.warn("[ContactsProvider] RolodexService not available");
       return { text: "", values: {}, data: {} };
@@ -80038,7 +80043,7 @@ var followUpsProvider = {
   name: spec36.name,
   description: spec36.description,
   get: async (runtime2, _message, _state2) => {
-    const followUpService = runtime2.getService("follow_up");
+    const followUpService = await runtime2.getService("follow_up");
     if (!followUpService) {
       runtime2.logger.warn("[FollowUpsProvider] FollowUpService not available");
       return { text: "", values: {}, data: {} };
@@ -81236,7 +81241,7 @@ var controlMessageHandler = async ({
   const serviceNames = Array.from(runtime2.getAllServices().keys());
   const websocketServiceName = serviceNames.find((name) => name.toLowerCase().includes("websocket") || name.toLowerCase().includes("socket"));
   if (websocketServiceName) {
-    const websocketService = runtime2.getService(websocketServiceName);
+    const websocketService = await runtime2.getService(websocketServiceName);
     if (websocketService && "sendMessage" in websocketService) {
       await websocketService.sendMessage({
         type: "controlMessage",
@@ -81344,7 +81349,7 @@ var events2 = {
     async (payload) => {
       const payloadContent = payload.content;
       if (payloadContent && payloadContent.source === "client_chat") {
-        const messageBusService = payload.runtime.getService("message-bus-service");
+        const messageBusService = await payload.runtime.getService("message-bus-service");
         if (messageBusService?.notifyActionStart) {
           await messageBusService.notifyActionStart(payload.roomId, payload.world, payload.content, payload.messageId);
         }
@@ -81382,7 +81387,7 @@ var events2 = {
     async (payload) => {
       const payloadContent = payload.content;
       if (payloadContent && payloadContent.source === "client_chat") {
-        const messageBusService = payload.runtime.getService("message-bus-service");
+        const messageBusService = await payload.runtime.getService("message-bus-service");
         if (messageBusService?.notifyActionUpdate) {
           await messageBusService.notifyActionUpdate(payload.roomId, payload.world, payload.content, payload.messageId);
         }
@@ -82263,6 +82268,126 @@ async function saveCharacter(character, filePath) {
   });
   logger.info(`Character saved to ${characterPath}`);
 }
+// src/connection.ts
+init_types5();
+init_utils5();
+function resolveWorldId(worldId, messageServerId, agentId) {
+  if (worldId)
+    return worldId;
+  if (messageServerId)
+    return stringToUuid(`${messageServerId}:${agentId}`);
+  throw new Error("worldId or messageServerId is required");
+}
+async function ensureConnections(adapter2, params) {
+  const { agentId, connections } = params;
+  if (!connections.length)
+    return;
+  const entityMap = new Map;
+  const worldMap = new Map;
+  const roomMap = new Map;
+  const roomParticipants = new Map;
+  for (const c of connections) {
+    const worldId = resolveWorldId(c.worldId, c.messageServerId, agentId);
+    const names4 = [c.name, c.userName].filter(Boolean);
+    const source = c.source || "default";
+    const entityKey = c.entityId;
+    if (!entityMap.has(entityKey)) {
+      entityMap.set(entityKey, {
+        entityId: c.entityId,
+        names: [],
+        metadata: {},
+        agentId
+      });
+    }
+    const ent = entityMap.get(entityKey);
+    if (!ent) {
+      continue;
+    }
+    ent.names = [...new Set([...ent.names, ...names4])].filter(Boolean);
+    ent.metadata[source] = {
+      id: c.userId,
+      name: c.name,
+      userName: c.userName
+    };
+    const world = {
+      id: worldId,
+      name: c.worldName ? c.worldName : c.messageServerId ? `World for server ${c.messageServerId}` : `World for room ${c.roomId}`,
+      agentId,
+      messageServerId: c.messageServerId,
+      metadata: c.metadata
+    };
+    worldMap.set(worldId, world);
+    const roomType = typeof c.type === "string" && Object.values(ChannelType).includes(c.type) ? c.type : ChannelType.DM;
+    const room = {
+      id: c.roomId,
+      name: c.name || "default",
+      source,
+      type: roomType,
+      channelId: c.channelId ?? c.roomId,
+      messageServerId: c.messageServerId,
+      worldId
+    };
+    roomMap.set(c.roomId, room);
+    if (!roomParticipants.has(c.roomId)) {
+      roomParticipants.set(c.roomId, new Set);
+    }
+    const participants = roomParticipants.get(c.roomId);
+    if (!participants) {
+      continue;
+    }
+    participants.add(c.entityId);
+    participants.add(agentId);
+  }
+  const entityIds = [...entityMap.keys()];
+  const existingEntities = entityIds.length > 0 ? await adapter2.getEntitiesByIds(entityIds) : [];
+  const existingByKey = new Map(existingEntities.map((e) => [e.id, e]));
+  const entities = [];
+  for (const [, v] of entityMap) {
+    const existing = existingByKey.get(v.entityId) ?? null;
+    const names4 = existing ? [...new Set([...existing.names || [], ...v.names])].filter(Boolean) : v.names;
+    const metadata = existing ? { ...existing.metadata, ...v.metadata } : v.metadata;
+    entities.push({
+      id: v.entityId,
+      names: names4,
+      metadata,
+      agentId: v.agentId
+    });
+  }
+  if (entities.length)
+    await adapter2.upsertEntities(entities);
+  const worlds = [...worldMap.values()].map((w) => ({
+    ...w,
+    agentId
+  }));
+  if (worlds.length)
+    await adapter2.upsertWorlds(worlds);
+  const rooms = [...roomMap.values()].map((r) => ({
+    ...r,
+    agentId
+  }));
+  if (rooms.length)
+    await adapter2.upsertRooms(rooms);
+  for (const [roomId, entityIdsSet] of roomParticipants) {
+    const currentResult = await adapter2.getParticipantsForRooms([
+      roomId
+    ]);
+    const current = currentResult[0]?.entityIds ?? [];
+    const missing = [...entityIdsSet].filter((id) => !current.includes(id));
+    if (missing.length) {
+      await adapter2.createRoomParticipants(missing, roomId);
+    }
+  }
+}
+async function ensureConnection(adapter2, params) {
+  if (!params.source) {
+    throw new Error("Source is required for ensureConnection");
+  }
+  const worldId = resolveWorldId(params.worldId, params.messageServerId, params.agentId);
+  await ensureConnections(adapter2, {
+    agentId: params.agentId,
+    connections: [{ ...params, worldId }]
+  });
+}
 // src/database.ts
 class DatabaseAdapter {
   db;
@@ -91595,7 +91720,7 @@ var skillEligibilityProvider = {
   position: -5,
   dynamic: true,
   get: async (runtime2, _message, _state2) => {
-    const service3 = runtime2.getService("AGENT_SKILLS_SERVICE");
+    const service3 = await runtime2.getService("AGENT_SKILLS_SERVICE");
     if (!service3) {
       return { text: "" };
     }
@@ -91697,7 +91822,7 @@ var skillEligibilityCompactProvider = {
   position: -5,
   dynamic: true,
   get: async (runtime2, _message, _state2) => {
-    const service3 = runtime2.getService("AGENT_SKILLS_SERVICE");
+    const service3 = await runtime2.getService("AGENT_SKILLS_SERVICE");
     if (!service3) {
       return { text: "" };
     }
@@ -91729,6 +91854,152 @@ var skillEligibilityCompactProvider = {
     }
   }
 };
+// src/provisioning.ts
+init_logger();
+init_types5();
+var logger2 = createLogger({ namespace: "provisioning", level: "info" });
+async function runPluginMigrations(runtime2) {
+  const adapter2 = runtime2.adapter;
+  if (!adapter2) {
+    logger2.warn({ src: "provisioning", agentId: runtime2.agentId }, "Database adapter not found, skipping plugin migrations");
+    return;
+  }
+  if (typeof adapter2.runPluginMigrations !== "function") {
+    logger2.warn({ src: "provisioning", agentId: runtime2.agentId }, "Database adapter does not support plugin migrations");
+    return;
+  }
+  const pluginsWithSchemas = runtime2.plugins.filter((p) => p.schema).map((p) => {
+    const schema2 = p.schema || {};
+    const normalizedSchema = {};
+    for (const [key, value] of Object.entries(schema2)) {
+      if (typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value === null || typeof value === "object" && value !== null) {
+        normalizedSchema[key] = value;
+      }
+    }
+    return { name: p.name, schema: normalizedSchema };
+  });
+  if (pluginsWithSchemas.length === 0) {
+    logger2.debug({ src: "provisioning", agentId: runtime2.agentId }, "No plugins with schemas, skipping migrations");
+    return;
+  }
+  const isProduction = typeof process !== "undefined" && process.env?.NODE_ENV === "production";
+  const forceDestructive = typeof process !== "undefined" && process.env?.ELIZA_ALLOW_DESTRUCTIVE_MIGRATIONS === "true";
+  await adapter2.runPluginMigrations(pluginsWithSchemas, {
+    verbose: !isProduction,
+    force: forceDestructive,
+    dryRun: false
+  });
+  logger2.debug({ src: "provisioning", agentId: runtime2.agentId }, "Plugin migrations completed");
+}
+async function ensureAgentInfrastructure(runtime2) {
+  const adapter2 = runtime2.adapter;
+  const agentId = runtime2.agentId;
+  const character = runtime2.character;
+  const existingAgent = await runtime2.ensureAgentExists({
+    ...character,
+    id: agentId
+  });
+  if (!existingAgent) {
+    throw new Error(`Agent ${agentId} does not exist in database after ensureAgentExists call`);
+  }
+  const entities = await adapter2.getEntitiesByIds([agentId]);
+  let agentEntity = entities[0] ?? null;
+  if (!agentEntity) {
+    await adapter2.createEntities([
+      {
+        id: agentId,
+        names: [character.name ?? "Agent"],
+        metadata: {},
+        agentId: existingAgent.id ?? agentId
+      }
+    ]);
+    const refetched = await adapter2.getEntitiesByIds([agentId]);
+    agentEntity = refetched[0] ?? null;
+    if (!agentEntity) {
+      throw new Error(`Agent entity not found for ${agentId}`);
+    }
+  }
+  const rooms = await adapter2.getRoomsByIds([agentId]);
+  if (rooms.length === 0) {
+    await adapter2.createRooms([
+      {
+        id: agentId,
+        name: character.name ?? "Agent",
+        source: "elizaos",
+        type: ChannelType.SELF,
+        channelId: agentId,
+        messageServerId: agentId,
+        worldId: agentId
+      }
+    ]);
+  }
+  const participantResults = await adapter2.getParticipantsForRooms([agentId]);
+  const participants = participantResults[0]?.entityIds ?? [];
+  if (!participants.includes(agentId)) {
+    await adapter2.createRoomParticipants([agentId], agentId);
+  }
+}
+async function ensureEmbeddingDimension(runtime2) {
+  const adapter2 = runtime2.adapter;
+  const model2 = runtime2.getModel("TEXT_EMBEDDING");
+  if (!model2) {
+    logger2.debug({ src: "provisioning", agentId: runtime2.agentId }, "No TEXT_EMBEDDING model registered, skipping embedding dimension");
+    return;
+  }
+  const raw2 = runtime2.getSetting("EMBEDDING_DIMENSION");
+  const dimension = typeof raw2 === "number" ? raw2 : typeof raw2 === "string" ? parseInt(raw2, 10) : NaN;
+  if (!Number.isFinite(dimension) || dimension <= 0) {
+    logger2.debug({ src: "provisioning", agentId: runtime2.agentId }, "EMBEDDING_DIMENSION not set or invalid, skipping (set it in character settings to avoid LLM detection)");
+    return;
+  }
+  await adapter2.ensureEmbeddingDimension(dimension);
+  logger2.debug({ src: "provisioning", agentId: runtime2.agentId, dimension }, "Embedding dimension set");
+}
+async function provisionAgent(runtime2, options = {}) {
+  const { runMigrations = true } = options;
+  if (runMigrations) {
+    await runPluginMigrations(runtime2);
+  }
+  await ensureAgentInfrastructure(runtime2);
+  await ensureEmbeddingDimension(runtime2);
+}
+async function mergeDbSettings(character, adapter2, agentId) {
+  const agents = await adapter2.getAgentsByIds([agentId]);
+  const existingAgent = agents[0] ?? null;
+  if (!existingAgent || !existingAgent.settings) {
+    return character;
+  }
+  const mergedSettings = {
+    ...existingAgent.settings,
+    ...character.settings
+  };
+  const dbSecrets = existingAgent.secrets && typeof existingAgent.secrets === "object" ? existingAgent.secrets : {};
+  const dbSettingsSecrets = existingAgent.settings.secrets && typeof existingAgent.settings.secrets === "object" ? existingAgent.settings.secrets : {};
+  const characterSecrets = character.secrets && typeof character.secrets === "object" ? character.secrets : {};
+  const characterSettingsSecrets = character.settings?.secrets && typeof character.settings.secrets === "object" ? character.settings.secrets : {};
+  const mergedSecrets = {
+    ...dbSecrets,
+    ...dbSettingsSecrets,
+    ...characterSecrets,
+    ...characterSettingsSecrets
+  };
+  if (Object.keys(mergedSecrets).length > 0) {
+    const filtered = {};
+    for (const [key, value] of Object.entries(mergedSecrets)) {
+      if (value !== null && value !== undefined) {
+        filtered[key] = String(value);
+      }
+    }
+    if (Object.keys(filtered).length > 0) {
+      mergedSettings.secrets = filtered;
+    }
+  }
+  return {
+    ...character,
+    settings: mergedSettings,
+    secrets: Object.keys(mergedSecrets).length > 0 ? mergedSettings.secrets : character.secrets
+  };
+}
 
 // src/index.node.ts
 init_roles();
@@ -91736,7 +92007,6 @@ init_roles();
 // src/runtime.ts
 init_dist_node();
 var import_handlebars2 = __toESM(require_lib(), 1);
-init_entities();
 init_logger();
 
 // src/search.ts
@@ -94912,1228 +95182,7 @@ Output ONLY the continuation, starting immediately after the last character abov
 init_types5();
 init_utils5();
 init_environment();
-// src/utils/prompt-batcher/batcher.ts
-init_prompt_batcher();
-
-// src/utils/text-normalize.ts
-function flattenTextValues(value) {
-  if (Array.isArray(value)) {
-    return value.flatMap((item) => flattenTextValues(item));
-  }
-  if (value == null) {
-    return [];
-  }
-  if (typeof value === "string") {
-    const trimmed = value.trim();
-    return trimmed ? [trimmed] : [];
-  }
-  if (typeof value === "object") {
-    return Object.entries(value).flatMap(([key, inner]) => {
-      const innerText = flattenTextValues(inner).join(", ");
-      return innerText ? [`${key}: ${innerText}`] : [];
-    });
-  }
-  return [String(value)];
-}
-function toMultilineText(value) {
-  return flattenTextValues(value).join(`
-`);
-}
-
-// src/utils/prompt-batcher/shared.ts
-class Semaphore {
-  permits;
-  queue = [];
-  constructor(count) {
-    this.permits = Math.max(1, count);
-  }
-  async acquire() {
-    if (this.permits > 0) {
-      this.permits -= 1;
-      return;
-    }
-    await new Promise((resolve) => {
-      this.queue.push(resolve);
-    });
-  }
-  release() {
-    this.permits += 1;
-    const next = this.queue.shift();
-    if (next && this.permits > 0) {
-      this.permits -= 1;
-      next();
-    }
-  }
-}
-function sanitizeIdentifier(value) {
-  const normalized = value.replace(/[^a-zA-Z0-9_]/g, "_");
-  if (/^[a-zA-Z_]/.test(normalized)) {
-    return normalized;
-  }
-  return `section_${normalized}`;
-}
-function clampRetryCount(value) {
-  if (typeof value !== "number" || Number.isNaN(value)) {
-    return 0;
-  }
-  return Math.max(0, Math.min(2, Math.floor(value)));
-}
-function createMinimalState(context) {
-  return {
-    text: context,
-    values: {
-      batcherContext: context
-    },
-    data: {}
-  };
-}
-function buildCharacterContext(runtime2) {
-  const topics = toMultilineText(runtime2.character.topics);
-  const bio = toMultilineText(runtime2.character.bio);
-  const style = toMultilineText(runtime2.character.style);
-  const knowledge2 = toMultilineText(runtime2.character.knowledge);
-  return [
-    `Agent Name: ${runtime2.character.name ?? "Unknown"}`,
-    bio ? `Bio:
-${bio}` : "",
-    style ? `Style:
-${style}` : "",
-    topics ? `Topics:
-${topics}` : "",
-    knowledge2 ? `Knowledge:
-${knowledge2}` : ""
-  ].filter(Boolean).join(`
-
-`);
-}
-function getSourceMessageId(message2) {
-  const metadata = message2.metadata ?? {};
-  const content = message2.content ?? {};
-  const discordId = metadata.discordMessageId;
-  if (typeof discordId === "string" && discordId) {
-    return `discord:${discordId}`;
-  }
-  const telegramId = content.messageId;
-  if (telegramId != null) {
-    return `telegram:${String(telegramId)}`;
-  }
-  const slack = metadata.slack;
-  if (slack && typeof slack === "object" && "messageTs" in slack) {
-    return `slack:${String(slack.messageTs)}`;
-  }
-  return `internal:${message2.id}`;
-}
-function pickFields(fields, schema2) {
-  const picked = {};
-  if (!fields) {
-    return picked;
-  }
-  for (const row of schema2) {
-    if (row.field in fields) {
-      picked[row.field] = fields[row.field];
-    }
-  }
-  return picked;
-}
-function hasMeaningfulSectionDrift(existing, incoming) {
-  const comparableExisting = {
-    frequency: existing.frequency,
-    providers: existing.providers,
-    preamble: existing.preamble,
-    schema: existing.schema,
-    priority: existing.priority,
-    model: existing.model,
-    affinityKey: existing.affinityKey
-  };
-  const comparableIncoming = {
-    frequency: incoming.frequency,
-    providers: incoming.providers,
-    preamble: incoming.preamble,
-    schema: incoming.schema,
-    priority: incoming.priority,
-    model: incoming.model,
-    affinityKey: incoming.affinityKey
-  };
-  return JSON.stringify(comparableExisting) !== JSON.stringify(comparableIncoming);
-}
-function rollingAverage(current, count, nextValue) {
-  if (count <= 1) {
-    return nextValue;
-  }
-  return current + (nextValue - current) / count;
-}
-
-// src/utils/prompt-batcher/batcher.ts
-class PromptBatcher {
-  runtime;
-  dispatcher;
-  settings;
-  sections = new Map;
-  pendingResults = new Map;
-  contextResolvers = new Map;
-  preCallbackHandlers = new Map;
-  messageBuffers = new Map;
-  processedMessageIds = new Set;
-  processedMessageOrder = [];
-  affinityLocks = new Map;
-  lastRunAt = new Map;
-  inMemoryCache = new Map;
-  stats = {
-    totalDrains: 0,
-    totalCalls: 0,
-    totalCacheHits: 0,
-    totalFallbacks: 0,
-    avgSectionsPerCall: 0,
-    avgDrainDurationMs: 0
-  };
-  enabled = false;
-  disposed = false;
-  affinityTaskIds = new Map;
-  constructor(runtime2, dispatcher, settings2) {
-    this.runtime = runtime2;
-    this.dispatcher = dispatcher;
-    this.settings = settings2;
-    this.runtime.initPromise.then(() => {
-      if (!this.disposed) {
-        this.enabled = true;
-        this.drain();
-      }
-    });
-  }
-  addSection(section) {
-    if (this.disposed) {
-      return Promise.reject(new BatcherDisposedError);
-    }
-    this._validateProviders(section.providers);
-    const existing = this.sections.get(section.id);
-    if (existing) {
-      if (hasMeaningfulSectionDrift(existing, section)) {
-        this.runtime.logger.warn({
-          src: "prompt-batcher",
-          agentId: this.runtime.agentId,
-          sectionId: section.id
-        }, "Duplicate prompt section ID registered with different configuration");
-      }
-      return Promise.resolve(null);
-    }
-    const normalized = {
-      ...section,
-      priority: section.priority ?? "normal",
-      model: section.model ?? "small",
-      isolated: section.isolated ?? false,
-      affinityKey: section.affinityKey ?? "default",
-      maxRetries: clampRetryCount(section.maxRetries)
-    };
-    this.sections.set(normalized.id, normalized);
-    const deferred = {};
-    const promise = new Promise((resolve, reject) => {
-      deferred.resolve = resolve;
-      deferred.reject = reject;
-    });
-    this.pendingResults.set(normalized.id, {
-      deferred,
-      resolved: false
-    });
-    this._ensureAffinityTask(normalized.affinityKey ?? "default");
-    if (this.enabled && (normalized.priority === "immediate" || normalized.frequency === "once" || normalized.frequency === "per-drain")) {
-      this.drainAffinityGroup(normalized.affinityKey ?? "default");
-    }
-    return promise;
-  }
-  removeSection(id) {
-    const section = this.sections.get(id);
-    const affinityKey = section?.affinityKey ?? "default";
-    this.sections.delete(id);
-    this.pendingResults.delete(id);
-    this.lastRunAt.delete(id);
-    if (this.getSectionCountForAffinity(affinityKey) === 0) {
-      this._removeAffinityTask(affinityKey);
-    } else {
-      this._syncAffinityTask(affinityKey);
-    }
-  }
-  registerContextResolver(slug, resolver) {
-    if (this.contextResolvers.has(slug)) {
-      this.runtime.logger.warn({
-        src: "prompt-batcher",
-        agentId: this.runtime.agentId,
-        slug
-      }, "Prompt batcher context resolver already registered; keeping first value");
-      return;
-    }
-    this.contextResolvers.set(slug, resolver);
-  }
-  registerPreCallbackHandler(handler2) {
-    if (this.preCallbackHandlers.has(handler2.id)) {
-      this.runtime.logger.warn({
-        src: "prompt-batcher",
-        agentId: this.runtime.agentId,
-        handlerId: handler2.id
-      }, "Prompt batcher pre-callback handler already registered");
-      return;
-    }
-    this.preCallbackHandlers.set(handler2.id, handler2);
-  }
-  getPreCallbackHandlers(actionName) {
-    return Array.from(this.preCallbackHandlers.values()).filter((handler2) => handler2.actionFilter.includes(actionName));
-  }
-  tick(message2) {
-    if (this.disposed)
-      return;
-    if (!message2)
-      return;
-    const sourceMessageId = getSourceMessageId(message2);
-    if (this.processedMessageIds.has(sourceMessageId))
-      return;
-    this.processedMessageIds.add(sourceMessageId);
-    this.processedMessageOrder.push(sourceMessageId);
-    if (this.processedMessageOrder.length > 1000) {
-      const oldest = this.processedMessageOrder.shift();
-      if (oldest)
-        this.processedMessageIds.delete(oldest);
-    }
-    this._pushMessage("default", message2);
-    this._pushMessage(`room:${String(message2.roomId)}`, message2);
-    this._pushMessage(`audit:${String(message2.roomId)}`, message2);
-    this._pushMessage("autonomy", message2);
-    const messageAffinities = [
-      "default",
-      `room:${String(message2.roomId)}`,
-      `audit:${String(message2.roomId)}`
-    ];
-    for (const affinityKey of messageAffinities) {
-      if (this._shouldDrainAffinity(affinityKey)) {
-        this.drainAffinityGroup(affinityKey);
-      }
-    }
-  }
-  _shouldDrainAffinity(affinityKey) {
-    if (!this.enabled)
-      return false;
-    const sections = Array.from(this.sections.values()).filter((s) => (s.affinityKey ?? "default") === affinityKey);
-    if (sections.some((s) => s.priority === "immediate"))
-      return true;
-    const buffer = this.messageBuffers.get(affinityKey) ?? [];
-    return buffer.length >= this.settings.batchSize;
-  }
-  async drain() {
-    if (this.disposed || !this.enabled) {
-      return;
-    }
-    const affinityKeys = this._getActiveAffinityKeys();
-    await Promise.allSettled(affinityKeys.map((affinityKey) => this.drainAffinityGroup(affinityKey)));
-  }
-  dispose() {
-    this.disposed = true;
-    if (typeof this.runtime.deleteTask === "function") {
-      for (const [, taskId] of this.affinityTaskIds) {
-        this.runtime.deleteTask(taskId).catch(() => {});
-      }
-    }
-    this.affinityTaskIds.clear();
-    for (const pending of this.pendingResults.values()) {
-      if (!pending.resolved) {
-        pending.resolved = true;
-        pending.deferred.reject(new BatcherDisposedError);
-      }
-    }
-    this.pendingResults.clear();
-    this.sections.clear();
-    this.messageBuffers.clear();
-    this.affinityLocks.clear();
-  }
-  invalidateCache(sectionId) {
-    const cacheKey = this._cacheKey(sectionId);
-    this.inMemoryCache.delete(cacheKey);
-    this.runtime.deleteCache(cacheKey);
-  }
-  invalidateAllCaches() {
-    for (const section of this.sections.values()) {
-      this.invalidateCache(section.id);
-    }
-  }
-  getStats() {
-    return { ...this.stats };
-  }
-  askOnce(id, opts) {
-    return this.addSection({
-      id,
-      frequency: "once",
-      priority: "background",
-      affinityKey: "init",
-      preamble: opts.preamble,
-      schema: opts.schema,
-      fallback: this._normalizeFallback(opts.fallback),
-      providers: opts.providers,
-      model: opts.model,
-      cacheTtlMs: opts.cacheTtlMs,
-      staleWhileRevalidate: opts.staleWhileRevalidate,
-      forceRegenerate: opts.forceRegenerate,
-      shouldRun: opts.shouldRun,
-      validate: opts.validate,
-      maxRetries: opts.maxRetries,
-      execOptions: opts.execOptions
-    }).then((result) => result?.fields ?? {});
-  }
-  onDrain(id, opts) {
-    return this.addSection({
-      id,
-      frequency: "per-drain",
-      priority: "normal",
-      affinityKey: opts.room ? `room:${opts.room}` : "default",
-      preamble: opts.preamble,
-      schema: opts.schema,
-      onResult: opts.onResult,
-      fallback: this._normalizeFallback(opts.fallback),
-      providers: opts.providers,
-      model: opts.model,
-      shouldRun: opts.shouldRun,
-      validate: opts.validate,
-      maxRetries: opts.maxRetries,
-      execOptions: opts.execOptions
-    });
-  }
-  think(id, opts) {
-    this.addSection({
-      id,
-      frequency: "recurring",
-      priority: "normal",
-      affinityKey: "autonomy",
-      contextBuilder: opts.contextBuilder,
-      preamble: opts.preamble,
-      schema: opts.schema,
-      onResult: opts.onResult,
-      fallback: this._normalizeFallback(opts.fallback),
-      minCycleMs: opts.minCycleMs,
-      model: opts.model,
-      shouldRun: opts.shouldRun,
-      validate: opts.validate,
-      maxRetries: opts.maxRetries,
-      execOptions: opts.execOptions
-    });
-  }
-  askNow(id, opts) {
-    return this.addSection({
-      id,
-      frequency: "once",
-      priority: "immediate",
-      affinityKey: opts.room ? `room:${opts.room}` : "default",
-      preamble: opts.preamble,
-      schema: opts.schema,
-      fallback: this._normalizeFallback(opts.fallback),
-      providers: opts.providers,
-      model: opts.model,
-      validate: opts.validate,
-      maxRetries: opts.maxRetries,
-      execOptions: opts.execOptions
-    }).then((result) => result?.fields ?? opts.fallback);
-  }
-  _pushMessage(key, message2) {
-    const buffer = this.messageBuffers.get(key) ?? [];
-    buffer.push(message2);
-    const maxBufferedMessages = Math.max(this.settings.batchSize * 4, 50);
-    if (buffer.length > maxBufferedMessages) {
-      buffer.splice(0, buffer.length - maxBufferedMessages);
-    }
-    this.messageBuffers.set(key, buffer);
-  }
-  _getActiveAffinityKeys() {
-    const keys2 = new Set;
-    for (const section of this.sections.values()) {
-      keys2.add(section.affinityKey ?? "default");
-    }
-    return Array.from(keys2);
-  }
-  getIdealTickInterval(affinityKey) {
-    const sections = Array.from(this.sections.values()).filter((s) => (s.affinityKey ?? "default") === affinityKey);
-    let minInterval = this.settings.maxDrainIntervalMs;
-    for (const section of sections) {
-      if (section.frequency === "recurring" && typeof section.minCycleMs === "number" && section.minCycleMs > 0) {
-        minInterval = Math.min(minInterval, section.minCycleMs);
-      }
-    }
-    return Math.min(minInterval, this.settings.maxDrainIntervalMs);
-  }
-  getSectionCountForAffinity(affinityKey) {
-    return Array.from(this.sections.values()).filter((s) => (s.affinityKey ?? "default") === affinityKey).length;
-  }
-  async _ensureAffinityTask(affinityKey) {
-    if (this.affinityTaskIds.has(affinityKey)) {
-      return;
-    }
-    if (typeof this.runtime.getTasksByName !== "function" || typeof this.runtime.createTask !== "function") {
-      return;
-    }
-    const existing = await this.runtime.getTasksByName("BATCHER_DRAIN");
-    const match2 = existing.find((t) => t.metadata?.affinityKey === affinityKey);
-    if (match2?.id) {
-      this.affinityTaskIds.set(affinityKey, match2.id);
-      return;
-    }
-    const interval = this.getIdealTickInterval(affinityKey);
-    const task2 = {
-      name: "BATCHER_DRAIN",
-      description: `Drain affinity group: ${affinityKey}`,
-      tags: ["queue", "repeat"],
-      metadata: {
-        affinityKey,
-        updateInterval: interval,
-        baseInterval: interval,
-        updatedAt: Date.now(),
-        maxFailures: -1
-      }
-    };
-    const id = await this.runtime.createTask(task2);
-    this.affinityTaskIds.set(affinityKey, id);
-  }
-  async _syncAffinityTask(affinityKey) {
-    const taskId = this.affinityTaskIds.get(affinityKey);
-    if (!taskId)
-      return;
-    if (typeof this.runtime.getTask !== "function" || typeof this.runtime.updateTask !== "function")
-      return;
-    const count = this.getSectionCountForAffinity(affinityKey);
-    if (count === 0) {
-      await this._removeAffinityTask(affinityKey);
-      return;
-    }
-    const task2 = await this.runtime.getTask(taskId);
-    if (!task2) {
-      this.affinityTaskIds.delete(affinityKey);
-      return;
-    }
-    const newInterval = this.getIdealTickInterval(affinityKey);
-    const current = task2.metadata?.updateInterval;
-    if (current !== newInterval) {
-      await this.runtime.updateTask(taskId, {
-        metadata: { ...task2.metadata, updateInterval: newInterval }
-      });
-    }
-  }
-  async _removeAffinityTask(affinityKey) {
-    const taskId = this.affinityTaskIds.get(affinityKey);
-    if (!taskId)
-      return;
-    if (typeof this.runtime.deleteTask !== "function") {
-      this.affinityTaskIds.delete(affinityKey);
-      return;
-    }
-    try {
-      await this.runtime.deleteTask(taskId);
-    } finally {
-      this.affinityTaskIds.delete(affinityKey);
-    }
-  }
-  async drainAffinityGroup(affinityKey) {
-    const existingLock = this.affinityLocks.get(affinityKey);
-    if (existingLock) {
-      await existingLock;
-    }
-    let release;
-    const lock = new Promise((resolve) => {
-      release = resolve;
-    });
-    this.affinityLocks.set(affinityKey, lock);
-    try {
-      await this._drainAffinityGroupUnlocked(affinityKey);
-    } finally {
-      release();
-      this.affinityLocks.delete(affinityKey);
-    }
-  }
-  async _drainAffinityGroupUnlocked(affinityKey) {
-    if (this.disposed || !this.enabled) {
-      return;
-    }
-    const drainStartedAt = Date.now();
-    const sections = Array.from(this.sections.values()).filter((section) => (section.affinityKey ?? "default") === affinityKey);
-    if (sections.length === 0) {
-      return;
-    }
-    const messages = this._getMessagesForAffinity(affinityKey);
-    const drainId = `${sanitizeIdentifier(affinityKey)}-${drainStartedAt}`;
-    const sectionsIncluded = [];
-    const sectionsSkipped = [];
-    const cacheHits = [];
-    const allCalls = [];
-    const firstPass = sections.filter((section) => !section.dependsOnEvaluators);
-    const secondPass = sections.filter((section) => section.dependsOnEvaluators);
-    allCalls.push(...await this._runDrainPass({
-      drainId,
-      affinityKey,
-      messages,
-      sections: firstPass,
-      sectionsIncluded,
-      sectionsSkipped,
-      cacheHits
-    }));
-    if (secondPass.length > 0) {
-      const secondPassMessages = this._getMessagesForAffinity(affinityKey);
-      allCalls.push(...await this._runDrainPass({
-        drainId,
-        affinityKey,
-        messages: secondPassMessages,
-        sections: secondPass,
-        sectionsIncluded,
-        sectionsSkipped,
-        cacheHits
-      }));
-    }
-    this.stats.totalDrains += 1;
-    this.stats.avgDrainDurationMs = rollingAverage(this.stats.avgDrainDurationMs, this.stats.totalDrains, Date.now() - drainStartedAt);
-    if (messages.length > 0) {
-      this.messageBuffers.set(affinityKey, []);
-    }
-    this._emitDrainLog({
-      drainId,
-      agentId: String(this.runtime.agentId),
-      affinityKey,
-      timestamp: drainStartedAt,
-      durationMs: Date.now() - drainStartedAt,
-      sectionsIncluded,
-      sectionsSkipped,
-      cacheHits,
-      callCount: allCalls.length,
-      calls: allCalls
-    });
-  }
-  async _runDrainPass(args) {
-    const resolverCache = new Map;
-    const active = [];
-    const now = Date.now();
-    for (const section of args.sections) {
-      if (section.frequency === "per-drain" && args.messages.length === 0) {
-        args.sectionsSkipped.push(section.id);
-        continue;
-      }
-      if (section.shouldRun) {
-        try {
-          const shouldRun = await section.shouldRun(this.runtime);
-          if (!shouldRun) {
-            args.sectionsSkipped.push(section.id);
-            continue;
-          }
-        } catch (error) {
-          this.runtime.logger.warn({
-            src: "prompt-batcher",
-            agentId: this.runtime.agentId,
-            sectionId: section.id,
-            error
-          }, "Prompt batcher shouldRun threw; skipping section");
-          args.sectionsSkipped.push(section.id);
-          continue;
-        }
-      }
-      const cacheState = await this._checkCache(section);
-      if (cacheState.hit && cacheState.fields) {
-        const validatedCached = this._runValidate(section, cacheState.fields);
-        if (validatedCached) {
-          this.stats.totalCacheHits += 1;
-          args.cacheHits.push(section.id);
-          await this._deliverSectionResult({
-            section,
-            fields: validatedCached,
-            meta: {
-              drainId: args.drainId,
-              timestamp: now,
-              messages: args.messages,
-              sectionId: section.id,
-              actualModel: section.model ?? "small",
-              durationMs: 0,
-              cacheHit: true,
-              staleRevalidation: cacheState.stale,
-              packedWith: [],
-              retryAttempt: 0,
-              fallbackUsed: false
-            },
-            removeOnceSection: !cacheState.stale
-          });
-          if (!cacheState.stale) {
-            continue;
-          }
-        } else {
-          this.invalidateCache(section.id);
-        }
-      }
-      const resolved = await this._resolveContext(section, args.messages, resolverCache);
-      if (!resolved) {
-        args.sectionsSkipped.push(section.id);
-        continue;
-      }
-      args.sectionsIncluded.push(section.id);
-      active.push(resolved);
-    }
-    if (active.length === 0) {
-      return [];
-    }
-    const outcome = await this.dispatcher.dispatch(active, this.runtime);
-    this.stats.totalCalls += outcome.calls.length;
-    this.stats.avgSectionsPerCall = rollingAverage(this.stats.avgSectionsPerCall, this.stats.totalCalls, outcome.calls.reduce((sum, call) => sum + call.sectionIds.length, 0) / Math.max(1, outcome.calls.length));
-    const retriedCallIds = new Set;
-    await Promise.allSettled(active.map(async (resolvedSection) => {
-      const baseMeta = this._metaForSection(resolvedSection, args.drainId, args.messages, outcome.calls);
-      const rawFields = outcome.results.get(resolvedSection.section.id);
-      if (!rawFields) {
-        const fallback2 = this._fallbackForSection(resolvedSection.section);
-        await this._deliverSectionResult({
-          section: resolvedSection.section,
-          fields: fallback2,
-          meta: { ...baseMeta, fallbackUsed: true },
-          removeOnceSection: true
-        });
-        return;
-      }
-      const validated = this._runValidate(resolvedSection.section, rawFields);
-      if (validated) {
-        await this._writeCache(resolvedSection.section, validated);
-        await this._deliverSectionResult({
-          section: resolvedSection.section,
-          fields: validated,
-          meta: baseMeta,
-          removeOnceSection: true
-        });
-        this.lastRunAt.set(resolvedSection.section.id, Date.now());
-        return;
-      }
-      const retryFields = await this._retrySection(resolvedSection, args.messages, 1, retriedCallIds);
-      if (retryFields) {
-        await this._writeCache(resolvedSection.section, retryFields);
-        await this._deliverSectionResult({
-          section: resolvedSection.section,
-          fields: retryFields,
-          meta: { ...baseMeta, retryAttempt: 1 },
-          removeOnceSection: true
-        });
-        this.lastRunAt.set(resolvedSection.section.id, Date.now());
-        return;
-      }
-      const fallback = this._fallbackForSection(resolvedSection.section);
-      await this._deliverSectionResult({
-        section: resolvedSection.section,
-        fields: fallback,
-        meta: { ...baseMeta, fallbackUsed: true },
-        removeOnceSection: true
-      });
-    }));
-    if (retriedCallIds.size > 0) {
-      outcome.calls.push({
-        model: "small",
-        sectionIds: Array.from(retriedCallIds),
-        estimatedTokens: 0,
-        durationMs: 0,
-        success: true,
-        retried: true,
-        fallbackUsed: []
-      });
-    }
-    return outcome.calls;
-  }
-  _metaForSection(section, drainId, messages, calls) {
-    const call = calls.find((item) => item.sectionIds.includes(section.section.id));
-    return {
-      drainId,
-      timestamp: Date.now(),
-      messages,
-      sectionId: section.section.id,
-      actualModel: call?.model ?? section.preferredModel,
-      durationMs: call?.durationMs ?? 0,
-      cacheHit: false,
-      staleRevalidation: false,
-      packedWith: (call?.sectionIds ?? []).filter((id) => id !== section.section.id),
-      retryAttempt: 0,
-      fallbackUsed: false
-    };
-  }
-  async _resolveContext(section, messages, resolverCache) {
-    const pieces = [];
-    const providers4 = section.providers ?? [];
-    const anchorMessage = messages[messages.length - 1];
-    if (providers4.length === 0) {
-      pieces.push(buildCharacterContext(this.runtime));
-    } else if (providers4.length === 1 && providers4[0] === "*") {
-      if (!anchorMessage) {
-        this.runtime.logger.warn({
-          src: "prompt-batcher",
-          agentId: this.runtime.agentId,
-          sectionId: section.id
-        }, "Prompt batcher section requires providers but no anchor message exists");
-        return null;
-      }
-      const state2 = await this.runtime.composeState(anchorMessage);
-      pieces.push(state2.text ?? "");
-    } else if (providers4.length > 0) {
-      if (!anchorMessage) {
-        this.runtime.logger.warn({
-          src: "prompt-batcher",
-          agentId: this.runtime.agentId,
-          sectionId: section.id
-        }, "Prompt batcher section requires selective providers but no anchor message exists");
-        return null;
-      }
-      const state2 = await this.runtime.composeState(anchorMessage, providers4, true);
-      pieces.push(state2.text ?? "");
-    }
-    if (section.contextBuilder) {
-      try {
-        const built = await section.contextBuilder(this.runtime, messages);
-        if (built) {
-          pieces.push(String(built));
-        }
-      } catch (error) {
-        this.runtime.logger.warn({
-          src: "prompt-batcher",
-          agentId: this.runtime.agentId,
-          sectionId: section.id,
-          error
-        }, "Prompt batcher contextBuilder failed; using placeholder context");
-        pieces.push("[context unavailable]");
-      }
-    }
-    for (const slug of section.contextResolvers ?? []) {
-      let resolvedText = resolverCache.get(slug);
-      if (!resolvedText) {
-        const resolver = this.contextResolvers.get(slug);
-        if (!resolver) {
-          this.runtime.logger.warn({
-            src: "prompt-batcher",
-            agentId: this.runtime.agentId,
-            sectionId: section.id,
-            slug
-          }, "Prompt batcher context resolver not found");
-          continue;
-        }
-        try {
-          resolvedText = String(await resolver(this.runtime, messages));
-        } catch (error) {
-          this.runtime.logger.warn({
-            src: "prompt-batcher",
-            agentId: this.runtime.agentId,
-            sectionId: section.id,
-            slug,
-            error
-          }, "Prompt batcher context resolver failed; using placeholder context");
-          resolvedText = "[context unavailable]";
-        }
-        resolverCache.set(slug, resolvedText);
-      }
-      if (resolvedText) {
-        pieces.push(resolvedText);
-      }
-    }
-    if ((section.providers == null || section.providers.length === 0) && Array.from(this.sections.values()).some((other) => other.id !== section.id && (other.affinityKey ?? "default") === (section.affinityKey ?? "default") && other.providers?.includes("*"))) {
-      this.runtime.logger.warn({
-        src: "prompt-batcher",
-        agentId: this.runtime.agentId,
-        sectionId: section.id,
-        affinityKey: section.affinityKey ?? "default"
-      }, "Prompt batcher affinity group mixes cheap and full-provider sections; consider separate affinity keys");
-    }
-    const resolvedContext = pieces.filter(Boolean).join(`
-
-`);
-    const schemaFieldCount = section.schema.length;
-    const estimatedTokens = Math.ceil((resolvedContext.length + JSON.stringify(section.schema).length) / 4);
-    return {
-      section,
-      resolvedContext,
-      contextCharCount: resolvedContext.length,
-      schemaFieldCount,
-      estimatedTokens,
-      priority: section.priority ?? "normal",
-      preferredModel: section.model ?? "small",
-      isolated: section.isolated ?? false,
-      affinityKey: section.affinityKey ?? "default",
-      execOptions: section.execOptions
-    };
-  }
-  _getMessagesForAffinity(affinityKey) {
-    return [...this.messageBuffers.get(affinityKey) ?? []];
-  }
-  async _deliverSectionResult(args) {
-    if (args.meta.fallbackUsed) {
-      this.stats.totalFallbacks += 1;
-    }
-    const pending = this.pendingResults.get(args.section.id);
-    if (!this.disposed && args.section.onResult) {
-      try {
-        await args.section.onResult(args.fields, args.meta);
-      } catch (error) {
-        this.runtime.logger.warn({
-          src: "prompt-batcher",
-          agentId: this.runtime.agentId,
-          sectionId: args.section.id,
-          error
-        }, "Prompt batcher onResult failed");
-        if (pending && !pending.resolved) {
-          pending.resolved = true;
-          pending.deferred.reject(error);
-        }
-        if (args.removeOnceSection && args.section.frequency === "once") {
-          this.sections.delete(args.section.id);
-          this.pendingResults.delete(args.section.id);
-        }
-        return;
-      }
-    }
-    if (pending && !pending.resolved) {
-      pending.resolved = true;
-      pending.deferred.resolve({ fields: args.fields, meta: args.meta });
-    }
-    if (args.removeOnceSection && args.section.frequency === "once") {
-      this.sections.delete(args.section.id);
-      this.pendingResults.delete(args.section.id);
-    }
-  }
-  _fallbackForSection(section) {
-    return section.fallback?.() ?? {};
-  }
-  _normalizeFallback(fallback) {
-    if (!fallback) {
-      return;
-    }
-    return () => ({ ...fallback });
-  }
-  async _checkCache(section) {
-    if (!section.cacheTtlMs || section.forceRegenerate) {
-      return { hit: false, stale: false };
-    }
-    const key = this._cacheKey(section.id);
-    let entry = this.inMemoryCache.get(key);
-    if (!entry) {
-      const persisted = await this.runtime.getCache(key);
-      if (persisted?.fields && typeof persisted.expiresAt === "number") {
-        entry = persisted;
-        this.inMemoryCache.set(key, persisted);
-      }
-    }
-    if (!entry) {
-      return { hit: false, stale: false };
-    }
-    if (entry.expiresAt > Date.now()) {
-      return { hit: true, stale: false, fields: entry.fields };
-    }
-    if (section.staleWhileRevalidate) {
-      return { hit: true, stale: true, fields: entry.fields };
-    }
-    return { hit: false, stale: false };
-  }
-  async _writeCache(section, fields) {
-    if (!section.cacheTtlMs) {
-      return;
-    }
-    const entry = {
-      fields,
-      expiresAt: Date.now() + section.cacheTtlMs
-    };
-    const key = this._cacheKey(section.id);
-    this.inMemoryCache.set(key, entry);
-    await this.runtime.setCache(key, entry);
-  }
-  _runValidate(section, fields) {
-    if (!section.validate) {
-      return fields;
-    }
-    try {
-      return section.validate(fields);
-    } catch (error) {
-      this.runtime.logger.warn({
-        src: "prompt-batcher",
-        agentId: this.runtime.agentId,
-        sectionId: section.id,
-        error
-      }, "Prompt batcher validate threw");
-      return null;
-    }
-  }
-  async _retrySection(resolvedSection, messages, attempt, retriedCallIds) {
-    const maxRetries = clampRetryCount(resolvedSection.section.maxRetries);
-    if (attempt > maxRetries) {
-      return null;
-    }
-    retriedCallIds.add(resolvedSection.section.id);
-    const prompt2 = [
-      "Previous attempt was invalid. Try again.",
-      resolvedSection.section.preamble ?? "",
-      `Context:
-${resolvedSection.resolvedContext || "[context unavailable]"}`,
-      "Return only the requested structured fields."
-    ].filter(Boolean).join(`
-
-`);
-    const response = await this.runtime.dynamicPromptExecFromState({
-      state: createMinimalState(resolvedSection.resolvedContext),
-      params: {
-        prompt: prompt2,
-        ...resolvedSection.execOptions ?? {}
-      },
-      schema: resolvedSection.section.schema,
-      options: {
-        modelSize: resolvedSection.preferredModel
-      }
-    });
-    if (!response) {
-      return null;
-    }
-    const validated = this._runValidate(resolvedSection.section, response);
-    if (validated) {
-      return validated;
-    }
-    return this._retrySection(resolvedSection, messages, attempt + 1, retriedCallIds);
-  }
-  _emitDrainLog(log) {
-    this.runtime.logger.debug({
-      src: "prompt-batcher",
-      agentId: this.runtime.agentId,
-      drain: log
-    }, "Prompt batcher drain completed");
-  }
-  _cacheKey(sectionId) {
-    return `prompt-batcher:${String(this.runtime.agentId)}:${sectionId}`;
-  }
-  _validateProviders(providers4) {
-    if (!providers4 || providers4.length === 0 || providers4.length === 1 && providers4[0] === "*") {
-      return;
-    }
-    const knownProviders = new Set(this.runtime.providers.map((provider) => provider.name));
-    for (const provider of providers4) {
-      if (!knownProviders.has(provider)) {
-        this.runtime.logger.warn({
-          src: "prompt-batcher",
-          agentId: this.runtime.agentId,
-          provider
-        }, "Prompt batcher section references unknown provider");
-      }
-    }
-  }
-}
-// src/utils/prompt-batcher/dispatcher.ts
-class PromptDispatcher {
-  settings;
-  constructor(settings2) {
-    this.settings = settings2;
-  }
-  async dispatch(resolved, runtime2) {
-    const results = new Map;
-    const calls = [];
-    const semaphore = new Semaphore(this.settings.maxParallelCalls);
-    const callPlans = this._buildCallPlans(resolved);
-    await Promise.all(callPlans.map(async (callPlan) => {
-      await semaphore.acquire();
-      const startedAt = Date.now();
-      try {
-        const prompt2 = this._buildPrompt(callPlan);
-        const schema2 = callPlan.sections.flatMap((resolvedSection) => {
-          const prefix = sanitizeIdentifier(resolvedSection.section.id);
-          return resolvedSection.section.schema.map((row) => ({
-            ...row,
-            field: `${prefix}__${row.field}`
-          }));
-        });
-        const mergedExecOptions = this._mergeExecOptions(callPlan.sections.map((item) => item.execOptions));
-        const state2 = createMinimalState(callPlan.sections.map((item) => `[${item.section.id}]
-${item.resolvedContext || "[context unavailable]"}`).join(`
 
-`));
-        const modelSize = callPlan.model;
-        const response = await runtime2.dynamicPromptExecFromState({
-          state: state2,
-          params: {
-            prompt: prompt2,
-            ...mergedExecOptions
-          },
-          schema: schema2,
-          options: {
-            modelSize,
-            key: `prompt-batcher:${callPlan.sections.map((item) => item.section.id).join(",")}`
-          }
-        });
-        const durationMs = Date.now() - startedAt;
-        if (!response) {
-          calls.push({
-            model: modelSize,
-            sectionIds: callPlan.sections.map((item) => item.section.id),
-            estimatedTokens: callPlan.totalEstimatedTokens,
-            durationMs,
-            success: false,
-            retried: false,
-            fallbackUsed: callPlan.sections.map((item) => item.section.id)
-          });
-          return;
-        }
-        for (const section of callPlan.sections) {
-          const prefix = `${sanitizeIdentifier(section.section.id)}__`;
-          const stripped = {};
-          for (const [key, value] of Object.entries(response)) {
-            if (key.startsWith(prefix)) {
-              stripped[key.slice(prefix.length)] = value;
-            }
-          }
-          results.set(section.section.id, stripped);
-        }
-        calls.push({
-          model: modelSize,
-          sectionIds: callPlan.sections.map((item) => item.section.id),
-          estimatedTokens: callPlan.totalEstimatedTokens,
-          durationMs,
-          success: true,
-          retried: false,
-          fallbackUsed: []
-        });
-      } finally {
-        semaphore.release();
-      }
-    }));
-    return { results, calls };
-  }
-  _buildCallPlans(resolved) {
-    const affinityGroups = new Map;
-    for (const section of resolved) {
-      const group = affinityGroups.get(section.affinityKey) ?? [];
-      group.push(section);
-      affinityGroups.set(section.affinityKey, group);
-    }
-    const callPlans = [];
-    for (const sections of affinityGroups.values()) {
-      for (const priority of ["immediate", "normal", "background"]) {
-        const prioritized = sections.filter((section) => section.priority === priority);
-        if (prioritized.length === 0) {
-          continue;
-        }
-        for (const modelGroup of this._splitByModelPreference(prioritized)) {
-          const isolated = modelGroup.sections.filter((item) => item.isolated);
-          const packable = modelGroup.sections.filter((item) => !item.isolated).sort((a, b) => b.estimatedTokens - a.estimatedTokens);
-          for (const item of isolated) {
-            callPlans.push({
-              sections: [item],
-              model: modelGroup.model,
-              totalEstimatedTokens: item.estimatedTokens,
-              priority
-            });
-          }
-          const tokenLimit = this._packingTokenLimit(priority);
-          let current = [];
-          let tokenCount = 0;
-          let fieldCount = 0;
-          for (const item of packable) {
-            const nextTokens = tokenCount + item.estimatedTokens;
-            const nextFieldCount = fieldCount + item.schemaFieldCount;
-            const exceedsTokens = nextTokens > tokenLimit;
-            const exceedsFields = nextFieldCount > this.settings.maxSectionsPerCall;
-            const exceedsPromptSafety = nextTokens > 8192;
-            if (current.length > 0 && (exceedsTokens || exceedsFields || exceedsPromptSafety)) {
-              callPlans.push({
-                sections: current,
-                model: modelGroup.model,
-                totalEstimatedTokens: tokenCount,
-                priority
-              });
-              current = [];
-              tokenCount = 0;
-              fieldCount = 0;
-            }
-            current.push(item);
-            tokenCount += item.estimatedTokens;
-            fieldCount += item.schemaFieldCount;
-          }
-          if (current.length > 0) {
-            callPlans.push({
-              sections: current,
-              model: modelGroup.model,
-              totalEstimatedTokens: tokenCount,
-              priority
-            });
-          }
-        }
-      }
-    }
-    return callPlans.sort((a, b) => this._priorityRank(a.priority) - this._priorityRank(b.priority));
-  }
-  _splitByModelPreference(sections) {
-    const small = sections.filter((section) => section.preferredModel === "small");
-    const large = sections.filter((section) => section.preferredModel === "large");
-    if (small.length === 0) {
-      return [{ model: "large", sections: large }];
-    }
-    if (large.length === 0) {
-      return [{ model: "small", sections: small }];
-    }
-    const normalizedSeparation = Math.max(0, Math.min(1, this.settings.modelSeparation));
-    const total = small.length + large.length;
-    const smallRatio = small.length / total;
-    const promoteSmallIntoLarge = smallRatio < 1 - normalizedSeparation;
-    if (promoteSmallIntoLarge) {
-      return [
-        {
-          model: "large",
-          sections: [...large, ...small]
-        }
-      ];
-    }
-    return [
-      { model: "large", sections: large },
-      { model: "small", sections: small }
-    ];
-  }
-  _packingTokenLimit(priority) {
-    const density = Math.max(0, Math.min(1, this.settings.packingDensity));
-    const densityFloor = 0.35 + density * 0.65;
-    const priorityMultiplier = priority === "immediate" ? 0.65 : priority === "normal" ? 0.85 : 1;
-    return Math.max(512, Math.floor(this.settings.maxTokensPerCall * densityFloor * priorityMultiplier));
-  }
-  _priorityRank(priority) {
-    return priority === "immediate" ? 0 : priority === "normal" ? 1 : 2;
-  }
-  _buildPrompt(callPlan) {
-    const sectionBlocks = callPlan.sections.map((resolvedSection, index) => {
-      const fieldList = resolvedSection.section.schema.map((row) => {
-        const prefix = sanitizeIdentifier(resolvedSection.section.id);
-        const namespacedField = `${prefix}__${row.field}`;
-        return `- ${namespacedField}: ${row.description}${row.required ? " (required)" : ""}`;
-      }).join(`
-`);
-      return [
-        `SECTION ${index + 1}: ${resolvedSection.section.id}`,
-        resolvedSection.section.preamble ? `Instructions:
-${resolvedSection.section.preamble}` : "",
-        `Context:
-${resolvedSection.resolvedContext || "[context unavailable]"}`,
-        `Output fields for this section:
-${fieldList}`
-      ].filter(Boolean).join(`
-
-`);
-    });
-    return [
-      "You are answering multiple independent structured sections in one response.",
-      "Read each section carefully.",
-      "Use only the context provided for that section.",
-      "Fill every requested field exactly once.",
-      "Do not mix facts between sections.",
-      "",
-      sectionBlocks.join(`
-
-====================
-
-`)
-    ].join(`
-`);
-  }
-  _mergeExecOptions(options) {
-    const temperatures = options.map((item) => item?.temperature).filter((item) => typeof item === "number");
-    const maxTokens = options.map((item) => item?.maxTokens).filter((item) => typeof item === "number");
-    const stopSequences = new Set;
-    for (const option of options) {
-      for (const stop of option?.stopSequences ?? []) {
-        stopSequences.add(stop);
-      }
-    }
-    return {
-      temperature: temperatures.length > 0 ? Math.min(...temperatures) : undefined,
-      maxTokens: maxTokens.length > 0 ? Math.max(...maxTokens) : undefined,
-      stopSequences: stopSequences.size > 0 ? Array.from(stopSequences) : undefined
-    };
-  }
-}
 // src/utils/type-guards.ts
 var NON_PLAIN_CONSTRUCTORS = new Set([
   Array,
@@ -96182,7 +95231,7 @@ function isPlainObject(value) {
 // src/runtime.ts
 var environmentSettings = {};
 
-class Semaphore2 {
+class Semaphore {
   permits;
   waiting = [];
   constructor(count) {
@@ -96209,18 +95258,6 @@ class Semaphore2 {
 function isTextStreamResult(value) {
   return typeof value === "object" && value !== null && "textStream" in value && "text" in value && "usage" in value && "finishReason" in value;
 }
-function parseNumberSetting(value, fallback) {
-  if (typeof value === "number" && Number.isFinite(value)) {
-    return value;
-  }
-  if (typeof value === "string") {
-    const parsed = Number(value);
-    if (Number.isFinite(parsed)) {
-      return parsed;
-    }
-  }
-  return fallback;
-}
 
 class AgentRuntime {
   #conversationLength = 100;
@@ -96246,16 +95283,15 @@ class AgentRuntime {
   characterPlugins = [];
   capabilityOptions = {};
   actionPlanningOption;
-  cachedEmbeddingDimension;
   llmModeOption;
   checkShouldRespondOption;
   isAnonymousCharacter = false;
   logger;
   enableAutonomy;
-  serverless;
   settings;
   servicePromiseHandlers = new Map;
   servicePromises = new Map;
+  startingServices = new Map;
   serviceRegistrationStatus = new Map;
   initPromise;
   initResolver;
@@ -96264,8 +95300,9 @@ class AgentRuntime {
   currentActionContext;
   maxWorkingMemoryEntries = 50;
   messageService = null;
-  promptBatcher;
-  constructor(opts = {}) {
+  companionUrl;
+  stopped = false;
+  constructor(opts) {
     let character;
     if (opts.character) {
       character = opts.character;
@@ -96312,26 +95349,11 @@ class AgentRuntime {
     if (opts.adapter) {
       this.registerDatabaseAdapter(opts.adapter);
     }
+    this.companionUrl = opts.companionUrl;
     this.fetch = opts.fetch ?? this.fetch;
     this.settings = opts.settings ?? environmentSettings;
-    this.promptBatcher = new PromptBatcher(this, new PromptDispatcher({
-      packingDensity: parseNumberSetting(this.getSetting("PROMPT_PACKING_DENSITY"), 0.5),
-      maxTokensPerCall: parseNumberSetting(this.getSetting("PROMPT_MAX_TOKENS_PER_CALL"), 4096),
-      maxParallelCalls: parseNumberSetting(this.getSetting("PROMPT_MAX_PARALLEL_CALLS"), 3),
-      modelSeparation: parseNumberSetting(this.getSetting("PROMPT_MODEL_SEPARATION"), 0.7),
-      maxSectionsPerCall: parseNumberSetting(this.getSetting("PROMPT_MAX_SECTIONS_PER_CALL"), 30)
-    }), {
-      batchSize: parseNumberSetting(this.getSetting("PROMPT_BATCH_SIZE"), 10),
-      maxDrainIntervalMs: parseNumberSetting(this.getSetting("PROMPT_MAX_DRAIN_INTERVAL_MS"), 300000),
-      maxSectionsPerCall: parseNumberSetting(this.getSetting("PROMPT_MAX_SECTIONS_PER_CALL"), 30),
-      packingDensity: parseNumberSetting(this.getSetting("PROMPT_PACKING_DENSITY"), 0.5),
-      maxTokensPerCall: parseNumberSetting(this.getSetting("PROMPT_MAX_TOKENS_PER_CALL"), 4096),
-      maxParallelCalls: parseNumberSetting(this.getSetting("PROMPT_MAX_PARALLEL_CALLS"), 3),
-      modelSeparation: parseNumberSetting(this.getSetting("PROMPT_MODEL_SEPARATION"), 0.7)
-    });
     const enableAutonomyFromSettings = this.character.settings?.ENABLE_AUTONOMY === true || this.character.settings?.ENABLE_AUTONOMY === "true";
     this.enableAutonomy = opts.enableAutonomy ?? enableAutonomyFromSettings;
-    this.serverless = opts.serverless ?? false;
     this.plugins = [];
     this.characterPlugins = opts.plugins ?? [];
     this.actionPlanningOption = opts.actionPlanning;
@@ -96417,8 +95439,7 @@ class AgentRuntime {
       this.logger.debug({ src: "agent", agentId: this.agentId, plugin: pluginToRegister.name }, "Plugin initialized");
     }
     if (pluginToRegister.adapter) {
-      this.logger.debug({ src: "agent", agentId: this.agentId, plugin: pluginToRegister.name }, "Registering database adapter");
-      this.registerDatabaseAdapter(pluginToRegister.adapter);
+      this.logger.debug({ src: "agent", agentId: this.agentId, plugin: pluginToRegister.name }, "Plugin declares adapter factory (handled pre-construction)");
     }
     if (pluginToRegister.actions) {
       for (const action of pluginToRegister.actions) {
@@ -96458,14 +95479,6 @@ class AgentRuntime {
     }
     if (pluginToRegister.services) {
       for (const service3 of pluginToRegister.services) {
-        if (service3 == null) {
-          this.logger.warn({
-            src: "agent",
-            agentId: this.agentId,
-            plugin: pluginToRegister.name
-          }, "Plugin has null/undefined entry in services array, skipping");
-          continue;
-        }
         const serviceType = service3.serviceType;
         this.logger.debug({
           src: "agent",
@@ -96477,32 +95490,41 @@ class AgentRuntime {
           this._createServiceResolver(serviceType);
         }
         this.serviceRegistrationStatus.set(serviceType, "pending");
-        this.registerService(service3).catch((error) => {
-          this.logger.error({
-            src: "agent",
-            agentId: this.agentId,
-            plugin: pluginToRegister.name,
-            serviceType,
-            error: error instanceof Error ? error.message : String(error)
-          }, "Service registration failed");
-          const handler2 = this.servicePromiseHandlers.get(serviceType);
-          if (handler2) {
-            const serviceError = new Error(`Service ${serviceType} from plugin ${pluginToRegister.name} failed to register: ${error instanceof Error ? error.message : String(error)}`);
-            handler2.reject(serviceError);
-            this.servicePromiseHandlers.delete(serviceType);
-            this.servicePromises.delete(serviceType);
-          }
-          this.serviceRegistrationStatus.set(serviceType, "failed");
-        });
+        if (!this.serviceTypes.has(serviceType)) {
+          this.serviceTypes.set(serviceType, []);
+        }
+        const services = this.serviceTypes.get(serviceType);
+        if (services) {
+          services.push(service3);
+        }
       }
     }
+    if (pluginToRegister.adapter) {
+      this.logger.debug({
+        src: "agent",
+        agentId: this.agentId,
+        plugin: pluginToRegister.name
+      }, "Registering database adapter");
+      const bootstrapSettings = this.getBootstrapSettings();
+      const adapter2 = await Promise.resolve(pluginToRegister.adapter(this.agentId, bootstrapSettings));
+      this.registerDatabaseAdapter(adapter2);
+    }
   }
   getAllServices() {
     return this.services;
   }
   async stop() {
+    if (this.stopped) {
+      this.logger.debug({ src: "agent", agentId: this.agentId }, "Runtime already stopped");
+      return;
+    }
+    this.stopped = true;
     this.logger.debug({ src: "agent", agentId: this.agentId }, "Stopping runtime");
-    this.promptBatcher.dispose();
+    const inFlight = Array.from(this.startingServices.values());
+    if (inFlight.length > 0) {
+      this.logger.debug({ src: "agent", agentId: this.agentId, count: inFlight.length }, "Waiting for in-flight service starts before stopping");
+      await Promise.all(inFlight);
+    }
     for (const [serviceType, services] of this.services) {
       this.logger.debug({ src: "agent", agentId: this.agentId, serviceType }, "Stopping service");
       for (const service3 of services) {
@@ -96514,6 +95536,20 @@ class AgentRuntime {
         }
       }
     }
+    const stopError = new Error("Runtime stopped");
+    for (const [serviceType, handler2] of this.servicePromiseHandlers) {
+      handler2.reject(stopError);
+      const promise = this.servicePromises.get(serviceType);
+      if (promise) {
+        promise.catch(() => {});
+      }
+    }
+    this.eventHandlers.clear();
+    this.events = {};
+    this.stateCache.clear();
+    this.servicePromises.clear();
+    this.servicePromiseHandlers.clear();
+    this.startingServices.clear();
   }
   async initialize(options) {
     const pluginRegistrationPromises = [];
@@ -96647,6 +95683,45 @@ class AgentRuntime {
       this.initResolver = undefined;
     }
   }
+  getBootstrapSettings() {
+    const out = {};
+    for (const [key, value] of Object.entries(process.env)) {
+      if (value !== undefined && value !== null && key) {
+        out[key] = String(value);
+      }
+    }
+    const settings2 = this.character.settings && typeof this.character.settings === "object" ? this.character.settings : {};
+    for (const [key, value] of Object.entries(settings2)) {
+      if (value === undefined || value === null) {
+        continue;
+      }
+      if (key === "secrets" && typeof value === "object") {
+        continue;
+      }
+      out[key] = typeof value === "string" ? value : String(value);
+    }
+    const secrets = this.character.settings?.secrets && typeof this.character.settings.secrets === "object" ? this.character.settings.secrets : {};
+    for (const [key, value] of Object.entries(secrets)) {
+      if (value !== undefined && value !== null) {
+        out[key] = String(value);
+      }
+    }
+    const topSecrets = this.character.secrets && typeof this.character.secrets === "object" ? this.character.secrets : {};
+    for (const [key, value] of Object.entries(topSecrets)) {
+      if (value !== undefined && value !== null) {
+        out[key] = String(value);
+      }
+    }
+    return out;
+  }
+  registerDatabaseAdapter(adapter2) {
+    if (this.adapter) {
+      this.logger.warn({ src: "agent", agentId: this.agentId }, "Database adapter already registered, ignoring");
+    } else {
+      this.adapter = adapter2;
+      this.logger.debug({ src: "agent", agentId: this.agentId }, "Database adapter registered");
+    }
+  }
   async runPluginMigrations() {
     if (!this.adapter) {
       this.logger.warn({ src: "agent", agentId: this.agentId }, "Database adapter not found, skipping plugin migrations");
@@ -96774,17 +95849,8 @@ class AgentRuntime {
     }
     return true;
   }
-  registerDatabaseAdapter(adapter2) {
-    if (this.adapter) {
-      this.logger.warn({ src: "agent", agentId: this.agentId }, "Database adapter already registered, ignoring");
-    } else {
-      this.adapter = adapter2;
-      this.logger.debug({ src: "agent", agentId: this.agentId }, "Database adapter registered");
-    }
-  }
   getMessagingAdapter() {
-    const adapter2 = this.adapter;
-    if (adapter2 && typeof adapter2.createMessageServer === "function" && typeof adapter2.createChannel === "function" && typeof adapter2.createMessage === "function") {
+    if (this.adapter && typeof this.adapter.createMessageServer === "function" && typeof this.adapter.createChannel === "function" && typeof this.adapter.createMessage === "function") {
       return this.adapter;
     }
     return null;
@@ -96805,15 +95871,15 @@ class AgentRuntime {
   getAllActions() {
     return [...this.actions];
   }
-  getFilteredActions(context) {
-    const policyService = this.getService("tool_policy");
+  async getFilteredActions(context) {
+    const policyService = await this.getService("tool_policy");
     if (!policyService || !context) {
       return [...this.actions];
     }
     return policyService.filterActions(this.actions, context);
   }
-  isActionAllowed(actionName, context) {
-    const policyService = this.getService("tool_policy");
+  async isActionAllowed(actionName, context) {
+    const policyService = await this.getService("tool_policy");
     if (!policyService) {
       return { allowed: true, reason: "No policy service available" };
     }
@@ -96933,16 +95999,10 @@ class AgentRuntime {
             currentStep: actionIndex + 1
           });
         }
-        if (message2.id && accumulatedState) {
-          this.stateCache.set(message2.id, accumulatedState);
-        }
-        const freshProviderState = await this.composeState(message2, ["RECENT_MESSAGES", "ACTION_STATE"], true);
-        accumulatedState = {
-          ...accumulatedState,
-          ...freshProviderState,
-          values: { ...accumulatedState?.values, ...freshProviderState.values },
-          data: { ...accumulatedState?.data, ...freshProviderState.data }
-        };
+        accumulatedState = await this.composeState(message2, [
+          "RECENT_MESSAGES",
+          "ACTION_STATE"
+        ]);
         if (actionPlan && accumulatedState.data) {
           accumulatedState.data.actionPlan = actionPlan;
           accumulatedState.data.actionResults = actionResults;
@@ -97198,81 +96258,10 @@ class AgentRuntime {
           }
         });
         if (callback) {
-          for (let content of storedCallbackData) {
+          for (const content of storedCallbackData) {
             if (content.text) {
               content.text = this.redactSecrets(content.text);
             }
-            const auditHandlers = this.promptBatcher.getPreCallbackHandlers(action.name);
-            if (auditHandlers.length > 0) {
-              let auditedContent = content;
-              const mergedSchema = auditHandlers.flatMap((handler2) => handler2.schema);
-              const mergedProviders = [
-                ...new Set(auditHandlers.flatMap((handler2) => handler2.providers ?? []))
-              ];
-              const mergedPreamble = auditHandlers.map((handler2) => `${handler2.preamble}
-
-Output to audit:
-${content.text ?? ""}`).join(`
-
----
-
-`);
-              const mergedStopSequences = new Set;
-              const mergedMaxTokens = [];
-              const mergedTemperatures = [];
-              for (const handler2 of auditHandlers) {
-                if (typeof handler2.execOptions?.maxTokens === "number") {
-                  mergedMaxTokens.push(handler2.execOptions.maxTokens);
-                }
-                if (typeof handler2.execOptions?.temperature === "number") {
-                  mergedTemperatures.push(handler2.execOptions.temperature);
-                }
-                for (const stopSequence of handler2.execOptions?.stopSequences ?? []) {
-                  mergedStopSequences.add(stopSequence);
-                }
-              }
-              const addSectionResult = await this.promptBatcher.addSection({
-                id: `audit-${action.name}-${Date.now()}`,
-                frequency: "once",
-                priority: "immediate",
-                providers: mergedProviders.length > 0 ? mergedProviders : undefined,
-                preamble: mergedPreamble,
-                affinityKey: `audit:${message2.roomId}`,
-                schema: mergedSchema,
-                model: auditHandlers.some((handler2) => handler2.model === "large") ? "large" : "small",
-                execOptions: {
-                  temperature: mergedTemperatures.length > 0 ? Math.min(...mergedTemperatures) : 0,
-                  maxTokens: mergedMaxTokens.length > 0 ? Math.max(...mergedMaxTokens) : undefined,
-                  stopSequences: mergedStopSequences.size > 0 ? Array.from(mergedStopSequences) : undefined
-                },
-                fallback: () => Object.assign({}, ...auditHandlers.map((handler2) => handler2.fallback?.() ?? {}))
-              });
-              const auditedFields = addSectionResult?.fields;
-              for (const handler2 of auditHandlers) {
-                const handlerFields = pickFields(auditedFields, handler2.schema);
-                const validatedFields = handler2.validate ? handler2.validate(handlerFields) ?? handler2.fallback?.() ?? handlerFields : handlerFields;
-                try {
-                  const nextContent = auditedContent ? handler2.apply(validatedFields, auditedContent) : null;
-                  if (!nextContent) {
-                    auditedContent = null;
-                    break;
-                  }
-                  auditedContent = nextContent;
-                } catch (error) {
-                  this.logger.warn({
-                    src: "agent",
-                    agentId: this.agentId,
-                    actionName: action.name,
-                    handlerId: handler2.id,
-                    error
-                  }, "Pre-callback audit apply failed; falling through to original content");
-                }
-              }
-              if (!auditedContent) {
-                continue;
-              }
-              content = auditedContent;
-            }
             await callback(content);
           }
         }
@@ -97323,7 +96312,7 @@ ${content.text ?? ""}`).join(`
         this.stateCache.set(`${message2.id}_action_results`, {
           values: { actionResults },
           data: { actionResults, actionPlan },
-          text: JSON.stringify(actionResults, safeReplacer())
+          text: JSON.stringify(actionResults)
         });
       }
     }
@@ -97333,12 +96322,6 @@ ${content.text ?? ""}`).join(`
     return cachedState?.data && cachedState.data.actionResults || [];
   }
   async evaluate(message2, state2, didRespond, callback, responses) {
-    const disableMemorySetting = this.getSetting("DISABLE_MEMORY_CREATION");
-    const disableMemoryCreation = disableMemorySetting === true || (typeof disableMemorySetting === "string" ? parseBooleanFromText(disableMemorySetting) : disableMemorySetting != null ? parseBooleanFromText(String(disableMemorySetting)) : false);
-    if (disableMemoryCreation) {
-      this.logger.debug({ src: "agent", agentId: this.agentId }, "Skipping evaluators because DISABLE_MEMORY_CREATION is enabled");
-      return [];
-    }
     const evaluatorPromises = this.evaluators.map(async (evaluator) => {
       if (!evaluator.handler) {
         return null;
@@ -97458,78 +96441,20 @@ ${content.text ?? ""}`).join(`
     }
     this.logger.success({ src: "agent", agentId: this.agentId, worldId: world.id }, "World connected");
   }
-  async ensureConnection({
-    entityId,
-    roomId,
-    worldId,
-    worldName,
-    userName,
-    name,
-    source,
-    type,
-    channelId,
-    messageServerId,
-    userId,
-    metadata
-  }) {
-    if (!worldId && messageServerId) {
-      worldId = createUniqueUuid(this, messageServerId);
-    }
-    if (!worldId) {
-      worldId = this.agentId;
-    }
-    const names4 = [name, userName].filter(Boolean);
-    if (!source) {
-      throw new Error("Source is required for ensureEntityExists");
-    }
-    const entityMetadata = {
-      [source]: {
-        id: userId,
-        name,
-        userName
-      }
-    };
-    const entity2 = (await this.adapter.getEntitiesByIds([entityId]))[0] ?? null;
-    const entityToUpsert = {
-      id: entityId,
-      names: entity2 ? [...new Set([...entity2.names || [], ...names4])].filter(Boolean) : names4,
-      metadata: entity2 ? {
-        ...entity2.metadata,
-        [source]: {
-          ...entity2.metadata?.[source] && typeof entity2.metadata[source] === "object" ? entity2.metadata[source] : {},
-          id: userId,
-          name,
-          userName
-        }
-      } : entityMetadata,
-      agentId: this.agentId
-    };
-    await this.adapter.upsertEntities([entityToUpsert]);
+  async ensureConnection(params) {
+    await ensureConnection(this.adapter, {
+      agentId: this.agentId,
+      worldId: params.worldId,
+      messageServerId: params.messageServerId,
+      ...params,
+      source: params.source ?? "default"
+    });
     this.logger.debug({
       src: "agent",
       agentId: this.agentId,
-      entityId,
-      userName: name || userName
-    }, entity2 ? "Entity updated" : "Entity created");
-    await this.ensureWorldExists({
-      id: worldId,
-      name: worldName || messageServerId ? `World for server ${messageServerId}` : `World for room ${roomId}`,
-      agentId: this.agentId,
-      messageServerId,
-      metadata
-    });
-    await this.ensureRoomExists({
-      id: roomId,
-      name: name || "default",
-      source: source || "default",
-      type: typeof type === "string" && Object.values(ChannelType).includes(type) ? type : ChannelType.DM,
-      channelId,
-      messageServerId,
-      worldId
-    });
-    await this.ensureParticipantInRoom(entityId, roomId);
-    await this.ensureParticipantInRoom(this.agentId, roomId);
-    this.logger.debug({ src: "agent", agentId: this.agentId, entityId, channelId: roomId }, "Entity connected");
+      entityId: params.entityId,
+      channelId: params.roomId
+    }, "Entity connected");
   }
   async ensureParticipantInRoom(entityId, roomId) {
     const entity2 = (await this.adapter.getEntitiesByIds([entityId]))[0] ?? null;
@@ -97540,13 +96465,13 @@ ${content.text ?? ""}`).join(`
     } else if (!entity2) {
       throw new Error(`User entity ${entityId} not found, cannot add as participant.`);
     }
-    const [participantsResult] = await this.adapter.getParticipantsForRooms([
+    const participantsResult = await this.adapter.getParticipantsForRooms([
       roomId
     ]);
-    const participantIds = participantsResult?.entityIds ?? [];
-    if (!participantIds.includes(entityId)) {
+    const participants = participantsResult[0]?.entityIds ?? [];
+    if (!participants.includes(entityId)) {
       const added = await this.adapter.createRoomParticipants([entityId], roomId);
-      if (!added.length) {
+      if (!added) {
         throw new Error(`Failed to add participant ${entityId} to room ${roomId}`);
       }
       if (entityId === this.agentId) {
@@ -97556,25 +96481,27 @@ ${content.text ?? ""}`).join(`
       }
     }
   }
-  async getParticipantsForEntities(entityIds) {
-    return await this.adapter.getParticipantsForEntities(entityIds);
-  }
-  async getParticipantsForRooms(roomIds) {
-    return await this.adapter.getParticipantsForRooms(roomIds);
-  }
   async getParticipantsForEntity(entityId) {
     return await this.adapter.getParticipantsForEntities([entityId]);
   }
+  async getParticipantsForEntities(entityIds) {
+    return await this.adapter.getParticipantsForEntities(entityIds);
+  }
   async getParticipantsForRoom(roomId) {
     const result = await this.adapter.getParticipantsForRooms([roomId]);
     return result[0]?.entityIds ?? [];
   }
-  async areRoomParticipants(pairs) {
-    return await this.adapter.areRoomParticipants(pairs);
+  async getParticipantsForRooms(roomIds) {
+    return await this.adapter.getParticipantsForRooms(roomIds);
   }
   async isRoomParticipant(roomId, entityId) {
-    const [ok] = await this.adapter.areRoomParticipants([{ roomId, entityId }]);
-    return ok ?? false;
+    const results = await this.adapter.areRoomParticipants([
+      { roomId, entityId }
+    ]);
+    return results[0] ?? false;
+  }
+  async areRoomParticipants(pairs) {
+    return await this.adapter.areRoomParticipants(pairs);
   }
   async addParticipant(entityId, roomId) {
     const ids = await this.adapter.createRoomParticipants([entityId], roomId);
@@ -97606,7 +96533,8 @@ ${content.text ?? ""}`).join(`
     worldId,
     metadata
   }) {
-    const resolvedWorldId = worldId ?? this.agentId;
+    if (!worldId)
+      throw new Error("worldId is required");
     const room = await this.getRoom(id);
     await this.adapter.upsertRooms([
       {
@@ -97617,7 +96545,7 @@ ${content.text ?? ""}`).join(`
         type,
         channelId,
         messageServerId,
-        worldId: resolvedWorldId,
+        worldId,
         metadata
       }
     ]);
@@ -97658,67 +96586,24 @@ ${content.text ?? ""}`).join(`
       }
     }
     providersToGet.sort((a, b) => (a.position || 0) - (b.position || 0));
-    const trajLogger = this.getService("trajectory_logger");
-    const composeStateStart = Date.now();
-    const providerTimings = [];
-    const PROVIDER_TIMEOUT = 30000;
+    const trajLogger = await this.getService("trajectory_logger");
     const providerData = await Promise.all(providersToGet.map(async (provider) => {
       const start = Date.now();
-      let timerId;
-      try {
-        const timeoutPromise = new Promise((_, reject) => {
-          timerId = setTimeout(() => reject(new Error(`Provider ${provider.name} timed out after ${PROVIDER_TIMEOUT}ms`)), PROVIDER_TIMEOUT);
-        });
-        const result = await Promise.race([
-          provider.get(this, message2, cachedState),
-          timeoutPromise
-        ]);
-        clearTimeout(timerId);
-        const duration2 = Date.now() - start;
-        providerTimings.push({ name: provider.name, durationMs: duration2 });
-        if (duration2 > 100) {
-          this.logger.debug({
-            src: "agent",
-            agentId: this.agentId,
-            provider: provider.name,
-            duration: duration2
-          }, "Slow provider");
-        }
-        return {
-          ...result,
-          providerName: provider.name
-        };
-      } catch (error) {
-        clearTimeout(timerId);
-        const duration2 = Date.now() - start;
-        this.logger.error({
+      const result = await provider.get(this, message2, cachedState);
+      const duration2 = Date.now() - start;
+      if (duration2 > 100) {
+        this.logger.debug({
           src: "agent",
           agentId: this.agentId,
           provider: provider.name,
-          duration: duration2,
-          error: error instanceof Error ? error.message : String(error)
-        }, "Provider error or timeout");
-        return {
-          values: {},
-          text: "",
-          data: {},
-          providerName: provider.name
-        };
+          duration: duration2
+        }, "Slow provider");
       }
+      return {
+        ...result,
+        providerName: provider.name
+      };
     }));
-    const composeStateEnd = Date.now();
-    const totalProviderTime = composeStateEnd - composeStateStart;
-    if (totalProviderTime > 500 || providerTimings.length > 5) {
-      const sortedTimings = [...providerTimings].sort((a, b) => b.durationMs - a.durationMs);
-      const topTimings = sortedTimings.slice(0, 5).map((t) => `${t.name}=${t.durationMs.toLocaleString()}ms`).join(", ");
-      this.logger.info({
-        src: "agent:composeState:profile",
-        agentId: this.agentId,
-        totalMs: totalProviderTime,
-        providerCount: providersToGet.length,
-        timings: sortedTimings
-      }, `[PROFILE:composeState] ${totalProviderTime.toLocaleString()}ms for ${providersToGet.length} providers. Top: ${topTimings}`);
-    }
     if (trajectoryStepId && trajLogger) {
       const userText = typeof message2.content?.text === "string" ? message2.content.text : "";
       for (const r of providerData) {
@@ -97788,18 +96673,94 @@ ${content.text ?? ""}`).join(`
     }
     return newState;
   }
-  getService(serviceName) {
-    const serviceInstances = this.services.get(serviceName);
-    if (!serviceInstances || serviceInstances.length === 0) {
-      this.logger.debug({ src: "agent", agentId: this.agentId, serviceName }, "Service not found");
+  async _ensureServiceStarted(serviceType) {
+    if (this.stopped)
+      return null;
+    const key = serviceType;
+    const instances = this.services.get(key);
+    if (instances && instances.length > 0) {
+      return instances[0];
+    }
+    const classes = this.serviceTypes.get(key);
+    if (!classes || classes.length === 0) {
       return null;
     }
-    return serviceInstances[0];
+    let inFlight = this.startingServices.get(key);
+    if (!inFlight) {
+      inFlight = (async () => {
+        let first = null;
+        for (const cls of classes) {
+          const result = await this._runServiceStart(key, serviceType, cls);
+          if (result && !first)
+            first = result;
+        }
+        return first;
+      })();
+      this.startingServices.set(key, inFlight);
+    }
+    try {
+      return await inFlight;
+    } finally {
+      this.startingServices.delete(key);
+    }
   }
-  getTypedService(serviceName) {
+  async _runServiceStart(key, serviceType, serviceDef) {
+    this.serviceRegistrationStatus.set(key, "registering");
+    await this.initPromise;
+    if (typeof serviceDef.start !== "function") {
+      this.logger.error({ src: "agent", agentId: this.agentId, serviceType }, "Service class has no static start method");
+      this.serviceRegistrationStatus.set(key, "failed");
+      return null;
+    }
+    try {
+      const serviceInstance = await serviceDef.start(this);
+      if (!serviceInstance) {
+        this.serviceRegistrationStatus.set(key, "failed");
+        return null;
+      }
+      if (!this.services.has(key)) {
+        this.services.set(key, []);
+      }
+      const serviceList = this.services.get(key);
+      if (serviceList) {
+        serviceList.push(serviceInstance);
+      }
+      const handler2 = this.servicePromiseHandlers.get(serviceType);
+      if (handler2) {
+        handler2.resolve(serviceInstance);
+        this.servicePromiseHandlers.delete(serviceType);
+      }
+      if (serviceDef.registerSendHandlers) {
+        serviceDef.registerSendHandlers(this, serviceInstance);
+      }
+      this.serviceRegistrationStatus.set(key, "registered");
+      return serviceInstance;
+    } catch (error) {
+      this.logger.error({
+        src: "agent",
+        agentId: this.agentId,
+        serviceType,
+        error: error instanceof Error ? error.message : String(error)
+      }, "Service start failed");
+      const handler2 = this.servicePromiseHandlers.get(serviceType);
+      if (handler2) {
+        handler2.reject(error instanceof Error ? error : new Error(String(error)));
+        this.servicePromiseHandlers.delete(serviceType);
+        this.servicePromises.delete(serviceType);
+      }
+      this.serviceRegistrationStatus.set(key, "failed");
+      return null;
+    }
+  }
+  async getService(serviceName) {
+    const instance = await this._ensureServiceStarted(serviceName);
+    return instance;
+  }
+  async getTypedService(serviceName) {
     return this.getService(serviceName);
   }
-  getServicesByType(serviceName) {
+  async getServicesByType(serviceName) {
+    await this._ensureServiceStarted(serviceName);
     const serviceInstances = this.services.get(serviceName);
     if (!serviceInstances || serviceInstances.length === 0) {
       this.logger.debug({ src: "agent", agentId: this.agentId, serviceName }, "No services found for type");
@@ -97808,11 +96769,11 @@ ${content.text ?? ""}`).join(`
     return serviceInstances;
   }
   getRegisteredServiceTypes() {
-    return Array.from(this.services.keys());
+    return Array.from(this.serviceTypes.keys());
   }
   hasService(serviceType) {
-    const serviceInstances = this.services.get(serviceType);
-    return serviceInstances !== undefined && serviceInstances.length > 0;
+    const classes = this.serviceTypes.get(serviceType);
+    return classes !== undefined && classes.length > 0;
   }
   getServiceRegistrationStatus(serviceType) {
     return this.serviceRegistrationStatus.get(serviceType) || "unknown";
@@ -97844,48 +96805,19 @@ ${content.text ?? ""}`).join(`
       this.logger.warn({ src: "agent", agentId: this.agentId, serviceName }, "Service missing serviceType property");
       return;
     }
-    this.logger.debug({ src: "agent", agentId: this.agentId, serviceType }, "Registering service");
-    this.serviceRegistrationStatus.set(serviceType, "registering");
-    this.logger.debug({ src: "agent", agentId: this.agentId, serviceType }, "Service waiting for init");
-    const initTimeout = new Promise((_, reject) => {
-      setTimeout(() => {
-        reject(new Error(`Service ${serviceType} registration timed out waiting for runtime initialization (30s timeout)`));
-      }, 30000);
-    });
-    await Promise.race([this.initPromise, initTimeout]);
-    if (typeof serviceDef.start !== "function") {
-      throw new Error(`Service ${serviceType} does not have a static start method. All services must implement static async start(runtime: IAgentRuntime): Promise<Service>.`);
-    }
-    const serviceInstance = await serviceDef.start(this);
-    if (!serviceInstance) {
-      throw new Error(`Service ${serviceType}  start() method returned null or undefined. It must return a Service instance.`);
-    }
-    if (!this.services.has(serviceType)) {
-      this.services.set(serviceType, []);
+    this.logger.debug({ src: "agent", agentId: this.agentId, serviceType }, "Registering service (lazy; start() on first getService)");
+    this.serviceRegistrationStatus.set(serviceType, "pending");
+    if (!this.servicePromises.has(serviceType)) {
+      this._createServiceResolver(serviceType);
     }
     if (!this.serviceTypes.has(serviceType)) {
       this.serviceTypes.set(serviceType, []);
     }
-    const servicesArray = this.services.get(serviceType);
-    if (servicesArray) {
-      servicesArray.push(serviceInstance);
-    }
-    const serviceTypesArray = this.serviceTypes.get(serviceType);
-    if (serviceTypesArray) {
-      serviceTypesArray.push(serviceDef);
-    }
-    const handler2 = this.servicePromiseHandlers.get(serviceType);
-    if (handler2) {
-      handler2.resolve(serviceInstance);
-      this.servicePromiseHandlers.delete(serviceType);
-    } else {
-      this.logger.debug({ src: "agent", agentId: this.agentId, serviceType }, "Service has no promise handler");
-    }
-    if (serviceDef.registerSendHandlers) {
-      serviceDef.registerSendHandlers(this, serviceInstance);
+    const serviceClassList = this.serviceTypes.get(serviceType);
+    if (!serviceClassList) {
+      return;
     }
-    this.serviceRegistrationStatus.set(serviceType, "registered");
-    this.logger.debug({ src: "agent", agentId: this.agentId, serviceType }, "Service registered");
+    serviceClassList.push(serviceDef);
   }
   _createServiceResolver(serviceType) {
     let resolver;
@@ -97911,11 +96843,11 @@ ${content.text ?? ""}`).join(`
     return promise;
   }
   getServiceLoadPromise(serviceType) {
-    let p = this.servicePromises.get(serviceType);
-    if (!p) {
-      p = this._createServiceResolver(serviceType);
-    }
-    return p;
+    return this.getService(serviceType).then((s) => {
+      if (!s)
+        throw new Error(`Service ${serviceType} not found or failed to start`);
+      return s;
+    });
   }
   registerModel(modelType, handler2, provider, priority) {
     const modelKey = typeof modelType === "string" ? modelType : ModelType[modelType];
@@ -98015,55 +96947,6 @@ ${content.text ?? ""}`).join(`
         });
       }
     }
-    const providerStr = provider || this.models.get(modelKey)?.[0]?.provider || "unknown";
-    const meta = {
-      agentName: this.character?.name,
-      agentId: this.agentId,
-      runId: this.getCurrentRunId(),
-      provider: providerStr,
-      actionContext: this.currentActionContext?.actionName
-    };
-    if (modelKey !== ModelType.TEXT_EMBEDDING && promptContent) {
-      const redactedPrompt = this.redactSecrets(promptContent);
-      const pSlug = logPrompt(modelKey, redactedPrompt, meta);
-      if (pSlug) {
-        this.logger.debug({
-          src: "agent",
-          agentId: this.agentId,
-          model: modelKey,
-          slug: pSlug,
-          chars: promptContent.length
-        }, `PROMPT ${pSlug}`);
-      }
-      let responseText;
-      if (typeof response === "string") {
-        responseText = this.redactSecrets(response);
-      } else if (Array.isArray(response) && response.every((x) => typeof x === "number")) {
-        responseText = "[embedding-array]";
-      } else {
-        try {
-          const raw2 = this.redactSecrets(JSON.stringify(response));
-          responseText = raw2.length > 1e5 ? raw2.substring(0, 1e5) + `... [truncated, ${raw2.length} total chars]` : raw2;
-        } catch {
-          responseText = "[non-serializable response]";
-        }
-      }
-      const rSlug = logResponse(modelKey, responseText, {
-        ...meta,
-        promptSlug: pSlug,
-        duration: Number(elapsedTime.toFixed(2))
-      });
-      if (rSlug) {
-        this.logger.debug({
-          src: "agent",
-          agentId: this.agentId,
-          model: modelKey,
-          slug: rSlug,
-          duration: Number(elapsedTime.toFixed(2)),
-          chars: responseText.length
-        }, `RESPONSE ${rSlug}`);
-      }
-    }
     const responseValue = Array.isArray(response) && response.every((x) => typeof x === "number") ? "[array]" : typeof response === "string" ? response : undefined;
     this.adapter.createLogs([
       {
@@ -98090,28 +96973,6 @@ ${content.text ?? ""}`).join(`
   }
   async useModel(modelType, params, provider) {
     let modelKey = typeof modelType === "string" ? modelType : ModelType[modelType];
-    let callerInfo = "unknown";
-    if (this.logger.level === "debug" || this.logger.level === "trace") {
-      try {
-        const stackLimit = Error.stackTraceLimit;
-        Error.stackTraceLimit = 5;
-        const stack = new Error().stack;
-        Error.stackTraceLimit = stackLimit;
-        callerInfo = stack?.split(`
-`).slice(2, 5).map((line) => line.trim().replace(/^at\s+/, "")).join(" <- ") || "unknown";
-      } catch {
-        callerInfo = "unknown (stack error)";
-      }
-    }
-    this.logger.debug({
-      src: "agent",
-      agentId: this.agentId,
-      model: modelKey,
-      caller: callerInfo,
-      provider: provider || "default",
-      actionContext: this.currentActionContext?.actionName,
-      runId: this.getCurrentRunId()
-    }, "useModel called");
     const llmMode = this.getLLMMode();
     if (llmMode !== "DEFAULT") {
       const textGenerationModels = [
@@ -98225,20 +97086,17 @@ ${content.text ?? ""}`).join(`
       if (ctxEnd)
         ctxEnd();
       const elapsedTime2 = (typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now()) - startTime;
-      this.logger.debug({
+      this.logger.trace({
         src: "agent",
         agentId: this.agentId,
         model: modelKey,
         duration: Number(elapsedTime2.toFixed(2)),
-        streaming: true,
-        caller: callerInfo,
-        provider: provider || this.models.get(modelKey)?.[0]?.provider || "unknown",
-        actionContext: this.currentActionContext?.actionName
-      }, "useModel completed (stream with callback complete)");
+        streaming: true
+      }, "Model output (stream with callback complete)");
       this.logModelCall(modelType, modelKey, params, promptContent, elapsedTime2, provider, fullText);
       try {
         const stepId = getTrajectoryContext()?.trajectoryStepId;
-        const trajLogger = this.getService("trajectory_logger");
+        const trajLogger = await this.getService("trajectory_logger");
         if (stepId && trajLogger) {
           const tempRaw = isPlainObject(modelParams) ? modelParams.temperature : undefined;
           const maxTokensRaw = isPlainObject(modelParams) ? modelParams.maxTokens : undefined;
@@ -98259,19 +97117,16 @@ ${content.text ?? ""}`).join(`
       return fullText;
     }
     const elapsedTime = (typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now()) - startTime;
-    this.logger.debug({
+    this.logger.trace({
       src: "agent",
       agentId: this.agentId,
       model: modelKey,
-      duration: Number(elapsedTime.toFixed(2)),
-      caller: callerInfo,
-      provider: provider || this.models.get(modelKey)?.[0]?.provider || "unknown",
-      actionContext: this.currentActionContext?.actionName
-    }, "useModel completed");
+      duration: Number(elapsedTime.toFixed(2))
+    }, "Model output");
     this.logModelCall(modelType, modelKey, params, promptContent, elapsedTime, provider, response);
     try {
       const stepId = getTrajectoryContext()?.trajectoryStepId;
-      const trajLogger = this.getService("trajectory_logger");
+      const trajLogger = await this.getService("trajectory_logger");
       if (stepId && trajLogger) {
         const tempRaw = isPlainObject(modelParams) ? modelParams.temperature : undefined;
         const maxTokensRaw = isPlainObject(modelParams) ? modelParams.maxTokens : undefined;
@@ -98801,47 +97656,6 @@ Please complete: ${diagnosis.missingFields.concat(diagnosis.invalidFields, diagn
     delete state2._smartRetryContext;
     return null;
   }
-  calculateBackoffDelay(config2, retryCount) {
-    if (typeof config2 === "number") {
-      return config2;
-    }
-    const { initialMs = 1000, multiplier = 2, maxMs = 30000 } = config2;
-    const delay = initialMs * multiplier ** (retryCount - 1);
-    return Math.min(delay, maxMs);
-  }
-  abortableSleep(ms, signal) {
-    if (signal?.aborted)
-      return Promise.resolve(true);
-    return new Promise((resolve) => {
-      const timeout = setTimeout(() => {
-        signal?.removeEventListener("abort", onAbort);
-        resolve(false);
-      }, ms);
-      const onAbort = () => {
-        clearTimeout(timeout);
-        resolve(true);
-      };
-      signal?.addEventListener("abort", onAbort, { once: true });
-    });
-  }
-  upgradeDoubleToTriple(tpl) {
-    const DOUBLE_BRACE_VAR = /(?<!\{)\{\{(?!#|\/|!|>|\{|else\b)(\s*)(\S+?)(\s*)\}\}(?!\})/g;
-    return tpl.replace(DOUBLE_BRACE_VAR, "{{{$1$2$3}}}");
-  }
-  normalizeStructuredResponse(responseContent, depth = 0) {
-    if (!responseContent)
-      return null;
-    const MAX_UNWRAP_DEPTH = 3;
-    if (depth >= MAX_UNWRAP_DEPTH)
-      return responseContent;
-    if ("response" in responseContent && typeof responseContent.response === "object" && responseContent.response !== null) {
-      const nested = responseContent.response;
-      if (Object.keys(nested).length > 0) {
-        return this.normalizeStructuredResponse(nested, depth + 1);
-      }
-    }
-    return responseContent;
-  }
   flattenSchemaRows(rows) {
     const flattened = [];
     for (const row of rows) {
@@ -99067,6 +97881,47 @@ Please complete: ${diagnosis.missingFields.concat(diagnosis.invalidFields, diagn
         return effectiveType;
     }
   }
+  calculateBackoffDelay(config2, retryCount) {
+    if (typeof config2 === "number") {
+      return config2;
+    }
+    const { initialMs = 1000, multiplier = 2, maxMs = 30000 } = config2;
+    const delay = initialMs * multiplier ** (retryCount - 1);
+    return Math.min(delay, maxMs);
+  }
+  abortableSleep(ms, signal) {
+    if (signal?.aborted)
+      return Promise.resolve(true);
+    return new Promise((resolve) => {
+      const timeout = setTimeout(() => {
+        signal?.removeEventListener("abort", onAbort);
+        resolve(false);
+      }, ms);
+      const onAbort = () => {
+        clearTimeout(timeout);
+        resolve(true);
+      };
+      signal?.addEventListener("abort", onAbort, { once: true });
+    });
+  }
+  upgradeDoubleToTriple(tpl) {
+    const DOUBLE_BRACE_VAR = /(?<!\{)\{\{(?!#|\/|!|>|\{|else\b)(\s*)(\S+?)(\s*)\}\}(?!\})/g;
+    return tpl.replace(DOUBLE_BRACE_VAR, "{{{$1$2$3}}}");
+  }
+  normalizeStructuredResponse(responseContent, depth = 0) {
+    if (!responseContent)
+      return null;
+    const MAX_UNWRAP_DEPTH = 3;
+    if (depth >= MAX_UNWRAP_DEPTH)
+      return responseContent;
+    if ("response" in responseContent && typeof responseContent.response === "object" && responseContent.response !== null) {
+      const nested = responseContent.response;
+      if (Object.keys(nested).length > 0) {
+        return this.normalizeStructuredResponse(nested, depth + 1);
+      }
+    }
+    return responseContent;
+  }
   registerEvent(event, handler2) {
     if (!this.events[event]) {
       this.events[event] = [];
@@ -99109,13 +97964,10 @@ Please complete: ${diagnosis.missingFields.concat(diagnosis.invalidFields, diagn
     if (!model2) {
       throw new Error("No TEXT_EMBEDDING model registered");
     }
-    const embedding = await this.useModel(ModelType.TEXT_EMBEDDING, {
-      text: "test"
-    });
+    const embedding = await this.useModel(ModelType.TEXT_EMBEDDING, null);
     if (!embedding || !embedding.length) {
       throw new Error("Invalid embedding received");
     }
-    this.cachedEmbeddingDimension = embedding.length;
     await this.adapter.ensureEmbeddingDimension(embedding.length);
     this.logger.debug({ src: "agent", agentId: this.agentId, dimension: embedding.length }, "Embedding dimension set");
   }
@@ -99262,12 +98114,15 @@ Please complete: ${diagnosis.missingFields.concat(diagnosis.invalidFields, diagn
     });
     return await this.adapter.upsertEntities(entities);
   }
-  async getComponentsForEntities(entityIds, worldId, sourceEntityId) {
-    return await this.adapter.getComponentsForEntities(entityIds, worldId, sourceEntityId);
-  }
   async getComponents(entityId, worldId, sourceEntityId) {
     return await this.adapter.getComponentsForEntities([entityId], worldId, sourceEntityId);
   }
+  async getComponentsByNaturalKeys(keys2) {
+    return await this.adapter.getComponentsByNaturalKeys(keys2);
+  }
+  async getComponentsForEntities(entityIds, worldId, sourceEntityId) {
+    return await this.adapter.getComponentsForEntities(entityIds, worldId, sourceEntityId);
+  }
   async addEmbeddingToMemory(memory2) {
     if (memory2.embedding) {
       return memory2;
@@ -99276,31 +98131,28 @@ Please complete: ${diagnosis.missingFields.concat(diagnosis.invalidFields, diagn
     if (!memoryText) {
       throw new Error("Cannot generate embedding: Memory content is empty");
     }
-    try {
-      memory2.embedding = await this.useModel(ModelType.TEXT_EMBEDDING, {
-        text: memoryText
-      });
-    } catch (error) {
-      this.logger.error({
-        src: "agent",
-        agentId: this.agentId,
-        error: error instanceof Error ? error.message : String(error)
-      }, "Embedding generation failed");
-      const dimension = this.cachedEmbeddingDimension || 1536;
-      memory2.embedding = new Array(dimension).fill(0);
-      this.logger.warn({ src: "agent", agentId: this.agentId, dimension }, "Using zero vector for failed embedding");
-    }
+    memory2.embedding = await this.useModel(ModelType.TEXT_EMBEDDING, {
+      text: memoryText
+    });
     return memory2;
   }
   async queueEmbeddingGeneration(memory2, priority) {
     priority = priority || "normal";
-    if (!memory2) {
+    if (!memory2 || memory2.embedding || !memory2.content?.text) {
       return;
     }
-    if (memory2.embedding) {
-      return;
-    }
-    if (!memory2.content || !memory2.content.text) {
+    if (this.companionUrl) {
+      const url = `${this.companionUrl.replace(/\/$/, "")}/embedding-generation`;
+      this.fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          agentId: this.agentId,
+          memory: memory2,
+          priority,
+          runId: this.getCurrentRunId()
+        })
+      }).catch(() => {});
       return;
     }
     await this.emitEvent("EMBEDDING_GENERATION_REQUESTED" /* EMBEDDING_GENERATION_REQUESTED */, {
@@ -99392,8 +98244,22 @@ Please complete: ${diagnosis.missingFields.concat(diagnosis.invalidFields, diagn
   async deleteAllMemories(roomIds, tableName) {
     await this.adapter.deleteAllMemories(roomIds, tableName);
   }
-  async countMemories(params) {
-    return await this.adapter.countMemories(params);
+  async countMemories(roomIdOrParams, unique, tableName) {
+    if (typeof roomIdOrParams === "string") {
+      return await this.adapter.countMemories({
+        roomIds: [roomIdOrParams],
+        unique,
+        tableName
+      });
+    }
+    return await this.adapter.countMemories({
+      roomIds: roomIdOrParams.roomId ? [roomIdOrParams.roomId] : undefined,
+      unique: roomIdOrParams.unique,
+      tableName: roomIdOrParams.tableName,
+      entityId: roomIdOrParams.entityId,
+      agentId: roomIdOrParams.agentId,
+      metadata: roomIdOrParams.metadata
+    });
   }
   async getLogs(params) {
     return await this.adapter.getLogs(params);
@@ -99463,7 +98329,8 @@ Please complete: ${diagnosis.missingFields.concat(diagnosis.invalidFields, diagn
     messageServerId,
     worldId
   }) {
-    const resolvedWorldId = worldId ?? this.agentId;
+    if (!worldId)
+      throw new Error("worldId is required");
     const res = await this.adapter.createRooms([
       {
         id,
@@ -99472,7 +98339,7 @@ Please complete: ${diagnosis.missingFields.concat(diagnosis.invalidFields, diagn
         type,
         channelId,
         messageServerId,
-        worldId: resolvedWorldId
+        worldId
       }
     ]);
     if (!res.length)
@@ -99485,49 +98352,43 @@ Please complete: ${diagnosis.missingFields.concat(diagnosis.invalidFields, diagn
   async upsertRooms(rooms) {
     return await this.adapter.upsertRooms(rooms);
   }
-  async deleteRoomsByWorldIds(worldIds) {
-    await this.adapter.deleteRoomsByWorldIds(worldIds);
-  }
-  async getRoomsByWorlds(worldIds, limit, offset) {
-    return await this.adapter.getRoomsByWorlds(worldIds, limit, offset);
-  }
-  async getRoomsForParticipants(entityIds) {
-    return await this.adapter.getRoomsForParticipants(entityIds);
-  }
   async deleteRoomsByWorldId(worldId) {
     await this.adapter.deleteRoomsByWorldIds([worldId]);
   }
   async getRoomsForParticipant(entityId) {
     return await this.adapter.getRoomsForParticipants([entityId]);
   }
+  async getRoomsForParticipants(entityIds) {
+    return await this.adapter.getRoomsForParticipants(entityIds);
+  }
   async getRooms(worldId) {
     return await this.adapter.getRoomsByWorlds([worldId]);
   }
   async getRoomsByWorld(worldId) {
     return await this.adapter.getRoomsByWorlds([worldId]);
   }
-  async getParticipantUserStates(pairs) {
-    return await this.adapter.getParticipantUserStates(pairs);
-  }
   async getParticipantUserState(roomId, entityId) {
-    const [state2] = await this.adapter.getParticipantUserStates([
+    const results = await this.adapter.getParticipantUserStates([
       { roomId, entityId }
     ]);
-    return state2 ?? null;
-  }
-  async updateParticipantUserStates(updates) {
-    await this.adapter.updateParticipantUserStates(updates);
+    return results[0] ?? null;
   }
   async updateParticipantUserState(roomId, entityId, state2) {
     await this.adapter.updateParticipantUserStates([
       { roomId, entityId, state: state2 }
     ]);
   }
-  async getRelationshipsByPairs(pairs) {
-    return await this.adapter.getRelationshipsByPairs(pairs);
+  async getParticipantUserStates(pairs) {
+    return await this.adapter.getParticipantUserStates(pairs);
+  }
+  async updateParticipantUserStates(updates) {
+    await this.adapter.updateParticipantUserStates(updates);
   }
   async getRelationships(params) {
-    return await this.adapter.getRelationships(params);
+    return await this.adapter.getRelationships({
+      entityIds: [params.entityId],
+      tags: params.tags
+    });
   }
   async getCaches(keys2) {
     return await this.adapter.getCaches(keys2);
@@ -99539,18 +98400,24 @@ Please complete: ${diagnosis.missingFields.concat(diagnosis.invalidFields, diagn
     return await this.adapter.deleteCaches(keys2);
   }
   async getTasks(params) {
-    return await this.adapter.getTasks(params);
+    return await this.adapter.getTasks({ ...params, agentIds: [this.agentId] });
   }
   async getTasksByName(name) {
     return await this.adapter.getTasksByName(name);
   }
+  _notifyCompanionTasksDirty() {
+    if (!this.companionUrl)
+      return;
+    const url = `${this.companionUrl.replace(/\/$/, "")}/task-dirty`;
+    this.fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ agentId: this.agentId })
+    }).catch(() => {});
+  }
   async createTask(task2) {
-    const taskWithAgent = { ...task2, agentId: task2.agentId ?? this.agentId };
-    const ids = await this.adapter.createTasks([taskWithAgent]);
-    const taskService = this.getService(ServiceType2.TASK);
-    if (taskService && "markDirty" in taskService) {
-      taskService.markDirty();
-    }
+    const ids = await this.adapter.createTasks([task2]);
+    this._notifyCompanionTasksDirty();
     return ids[0];
   }
   async getTask(id) {
@@ -99559,17 +98426,10 @@ Please complete: ${diagnosis.missingFields.concat(diagnosis.invalidFields, diagn
   }
   async updateTask(id, task2) {
     await this.adapter.updateTasks([{ id, task: task2 }]);
-    const taskService = this.getService(ServiceType2.TASK);
-    if (taskService && "markDirty" in taskService) {
-      taskService.markDirty();
-    }
+    this._notifyCompanionTasksDirty();
   }
   async deleteTask(id) {
-    await this.adapter.deleteTasks([id]);
-    const taskService = this.getService(ServiceType2.TASK);
-    if (taskService && "markDirty" in taskService) {
-      taskService.markDirty();
-    }
+    return await this.adapter.deleteTasks([id]);
   }
   async log(params) {
     return await this.adapter.createLogs([params]);
@@ -99588,15 +98448,8 @@ Please complete: ${diagnosis.missingFields.concat(diagnosis.invalidFields, diagn
     return await this.adapter.deleteCaches([key]);
   }
   async createTasks(tasks) {
-    const tasksWithAgent = tasks.map((t) => ({
-      ...t,
-      agentId: t.agentId ?? this.agentId
-    }));
-    const ids = await this.adapter.createTasks(tasksWithAgent);
-    const taskService = this.getService(ServiceType2.TASK);
-    if (taskService && "markDirty" in taskService) {
-      taskService.markDirty();
-    }
+    const ids = await this.adapter.createTasks(tasks);
+    this._notifyCompanionTasksDirty();
     return ids;
   }
   async getTasksByIds(taskIds) {
@@ -99604,17 +98457,10 @@ Please complete: ${diagnosis.missingFields.concat(diagnosis.invalidFields, diagn
   }
   async updateTasks(updates) {
     await this.adapter.updateTasks(updates);
-    const taskService = this.getService(ServiceType2.TASK);
-    if (taskService && "markDirty" in taskService) {
-      taskService.markDirty();
-    }
+    this._notifyCompanionTasksDirty();
   }
   async deleteTasks(taskIds) {
-    await this.adapter.deleteTasks(taskIds);
-    const taskService = this.getService(ServiceType2.TASK);
-    if (taskService && "markDirty" in taskService) {
-      taskService.markDirty();
-    }
+    return await this.adapter.deleteTasks(taskIds);
   }
   async transaction(callback, options) {
     return await this.adapter.transaction(callback, options);
@@ -99666,14 +98512,11 @@ Please complete: ${diagnosis.missingFields.concat(diagnosis.invalidFields, diagn
     const ids = await this.adapter.createComponents([component]);
     return ids.length > 0;
   }
-  async getComponentsByNaturalKeys(keys2) {
-    return await this.adapter.getComponentsByNaturalKeys(keys2);
-  }
   async getComponent(entityId, type, worldId, sourceEntityId) {
-    const [component] = await this.adapter.getComponentsByNaturalKeys([
+    const results = await this.adapter.getComponentsByNaturalKeys([
       { entityId, type, worldId, sourceEntityId }
     ]);
-    return component ?? null;
+    return results[0] ?? null;
   }
   async updateComponent(component) {
     return await this.adapter.updateComponents([component]);
@@ -99687,14 +98530,14 @@ Please complete: ${diagnosis.missingFields.concat(diagnosis.invalidFields, diagn
   async upsertComponents(components2, options) {
     return await this.adapter.upsertComponents(components2, options);
   }
+  async patchComponent(componentId, ops, options) {
+    return await this.adapter.patchComponents([{ componentId, ops }], options);
+  }
   async patchComponents(updates, options) {
     return await this.adapter.patchComponents(updates, options);
   }
-  async patchComponent(componentId, ops, options) {
-    await this.adapter.patchComponents([{ componentId, ops }], options);
-  }
   async patchComponentField(componentId, op, options) {
-    await this.adapter.patchComponents([{ componentId, ops: [op] }], options);
+    return await this.adapter.patchComponents([{ componentId, ops: [op] }], options);
   }
   async getComponentsByType(type, agentId, options) {
     const entities = await this.adapter.queryEntities({
@@ -99738,6 +98581,9 @@ Please complete: ${diagnosis.missingFields.concat(diagnosis.invalidFields, diagn
   async getRelationshipsByIds(relationshipIds) {
     return await this.adapter.getRelationshipsByIds(relationshipIds);
   }
+  async getRelationshipsByPairs(pairs) {
+    return await this.adapter.getRelationshipsByPairs(pairs);
+  }
   async updateRelationships(relationships) {
     return await this.adapter.updateRelationships(relationships);
   }
@@ -99749,8 +98595,8 @@ Please complete: ${diagnosis.missingFields.concat(diagnosis.invalidFields, diagn
     return ids.length > 0;
   }
   async getRelationship(params) {
-    const [rel] = await this.adapter.getRelationshipsByPairs([params]);
-    return rel ?? null;
+    const results = await this.adapter.getRelationshipsByPairs([params]);
+    return results[0] ?? null;
   }
   async updateRelationship(relationship) {
     return await this.adapter.updateRelationships([relationship]);
@@ -99894,26 +98740,23 @@ Please complete: ${diagnosis.missingFields.concat(diagnosis.invalidFields, diagn
     }
     return await this.adapter.isReady();
   }
-  async getPairingRequests(queriesOrChannel, agentId) {
-    if (Array.isArray(queriesOrChannel)) {
-      return await this.adapter.getPairingRequests(queriesOrChannel);
-    }
-    if (agentId === undefined || agentId === null) {
-      return [];
-    }
-    const result = await this.adapter.getPairingRequests([
-      { channel: queriesOrChannel, agentId }
+  async getPairingRequestsForChannel(channel, agentId) {
+    const results = await this.adapter.getPairingRequests([
+      { channel, agentId }
     ]);
-    return result[0]?.requests ?? [];
+    return results[0]?.requests ?? [];
   }
-  async getPairingAllowlists(queries) {
-    return await this.adapter.getPairingAllowlists(queries);
+  async getPairingRequests(queries) {
+    return await this.adapter.getPairingRequests(queries);
   }
-  async getPairingAllowlist(channel, agentId) {
-    const result = await this.adapter.getPairingAllowlists([
+  async getPairingAllowlistForChannel(channel, agentId) {
+    const results = await this.adapter.getPairingAllowlists([
       { channel, agentId }
     ]);
-    return result[0]?.entries ?? [];
+    return results[0]?.entries ?? [];
+  }
+  async getPairingAllowlists(queries) {
+    return await this.adapter.getPairingAllowlists(queries);
   }
   async createPairingRequests(requests) {
     return await this.adapter.createPairingRequests(requests);
@@ -99950,6 +98793,221 @@ Please complete: ${diagnosis.missingFields.concat(diagnosis.invalidFields, diagn
   async deletePairingAllowlistEntry(id) {
     return await this.adapter.deletePairingAllowlistEntries([id]);
   }
+  async deleteRoomsByWorldIds(worldIds) {
+    return this.adapter.deleteRoomsByWorldIds(worldIds);
+  }
+  async getRoomsByWorlds(worldIds, limit, offset) {
+    return this.adapter.getRoomsByWorlds(worldIds, limit, offset);
+  }
+}
+// src/runtime-composition.ts
+init_utils5();
+function getBootstrapSettings(character, env2 = process.env) {
+  const out = {};
+  for (const [key, value] of Object.entries(env2)) {
+    if (value !== undefined && value !== null && key) {
+      out[key] = String(value);
+    }
+  }
+  const settings2 = character.settings && typeof character.settings === "object" ? character.settings : {};
+  for (const [key, value] of Object.entries(settings2)) {
+    if (value === undefined || value === null)
+      continue;
+    if (key === "secrets" && typeof value === "object")
+      continue;
+    out[key] = typeof value === "string" ? value : String(value);
+  }
+  const secrets = character.settings?.secrets && typeof character.settings.secrets === "object" ? character.settings.secrets : {};
+  for (const [key, value] of Object.entries(secrets)) {
+    if (value !== undefined && value !== null) {
+      out[key] = String(value);
+    }
+  }
+  const topSecrets = character.secrets && typeof character.secrets === "object" ? character.secrets : {};
+  for (const [key, value] of Object.entries(topSecrets)) {
+    if (value !== undefined && value !== null) {
+      out[key] = String(value);
+    }
+  }
+  return out;
+}
+function mergeSettingsInto(character, agentRecord) {
+  if (!agentRecord?.settings) {
+    return character;
+  }
+  const mergedSettings = {
+    ...agentRecord.settings,
+    ...character.settings
+  };
+  const dbSecrets = agentRecord.secrets && typeof agentRecord.secrets === "object" ? agentRecord.secrets : {};
+  const dbSettingsSecrets = agentRecord.settings.secrets && typeof agentRecord.settings.secrets === "object" ? agentRecord.settings.secrets : {};
+  const characterSecrets = character.secrets && typeof character.secrets === "object" ? character.secrets : {};
+  const characterSettingsSecrets = character.settings?.secrets && typeof character.settings.secrets === "object" ? character.settings.secrets : {};
+  const mergedSecrets = {
+    ...dbSecrets,
+    ...dbSettingsSecrets,
+    ...characterSecrets,
+    ...characterSettingsSecrets
+  };
+  if (Object.keys(mergedSecrets).length > 0) {
+    const filtered = {};
+    for (const [key, value] of Object.entries(mergedSecrets)) {
+      if (value !== null && value !== undefined) {
+        filtered[key] = String(value);
+      }
+    }
+    if (Object.keys(filtered).length > 0) {
+      mergedSettings.secrets = filtered;
+    }
+  }
+  return {
+    ...character,
+    settings: mergedSettings,
+    secrets: Object.keys(mergedSecrets).length > 0 ? mergedSettings.secrets : character.secrets
+  };
+}
+async function loadOneCharacterFromFile(filePath) {
+  const loaded = await loadCharacterFile(filePath);
+  if (loaded == null) {
+    throw new Error(`Failed to load character file: ${filePath}`);
+  }
+  let character = importSecretsFromEnv(loaded, COMMON_SECRET_KEYS);
+  character = ensureEncryptionSalt(character);
+  if (!character.id) {
+    character = {
+      ...character,
+      id: stringToUuid(character.name ?? "eliza")
+    };
+  }
+  return character;
+}
+function loadOneCharacterFromObject(input) {
+  const character = parseCharacter(input);
+  let out = importSecretsFromEnv(character, COMMON_SECRET_KEYS);
+  out = ensureEncryptionSalt(out);
+  if (!out.id) {
+    out = { ...out, id: stringToUuid(out.name ?? "eliza") };
+  }
+  return out;
+}
+async function loadCharacters(sources) {
+  if (sources.length === 0) {
+    return [];
+  }
+  const results = [];
+  for (const source of sources) {
+    if (typeof source === "string") {
+      const character = await loadOneCharacterFromFile(source);
+      results.push(character);
+    } else {
+      const character = loadOneCharacterFromObject(source);
+      results.push(character);
+    }
+  }
+  return results;
+}
+async function createRuntimes(characters, options) {
+  if (characters.length === 0) {
+    return [];
+  }
+  const pluginNames = new Set;
+  for (const c of characters) {
+    for (const p of c.plugins ?? []) {
+      if (typeof p === "string")
+        pluginNames.add(p);
+    }
+  }
+  const pluginInput = [...pluginNames];
+  if (options?.sharedPlugins?.length) {
+    pluginInput.push(...options.sharedPlugins);
+  }
+  const resolvedPlugins = await resolvePlugins(pluginInput);
+  const agentIds = [];
+  for (const c of characters) {
+    agentIds.push(c.id ?? stringToUuid(c.name ?? "eliza"));
+  }
+  let adapters;
+  if (options?.adapter) {
+    const defaultAdapter = options.adapter;
+    adapters = characters.map(() => defaultAdapter);
+  } else {
+    const adapterPlugin = resolvedPlugins.find((p) => typeof p.adapter === "function");
+    if (!adapterPlugin) {
+      const first = characters[0];
+      const nameOrId = first?.name ?? first?.id ?? "unknown";
+      throw new Error(`No plugin provides a database adapter for character ${String(nameOrId)}`);
+    }
+    adapters = await Promise.all(characters.map((c) => {
+      const agentId = c.id ?? stringToUuid(c.name ?? "eliza");
+      const settings2 = getBootstrapSettings(c);
+      return Promise.resolve(adapterPlugin.adapter(agentId, settings2));
+    }));
+  }
+  const seenAdapters = new Set;
+  for (const adapter2 of adapters) {
+    if (seenAdapters.has(adapter2))
+      continue;
+    seenAdapters.add(adapter2);
+    if (!await adapter2.isReady()) {
+      await adapter2.initialize();
+    }
+  }
+  const adapterToAgentIds = new Map;
+  for (let i = 0;i < characters.length; i++) {
+    const adapter2 = adapters[i];
+    const agentId = agentIds[i];
+    if (!adapter2 || !agentId) {
+      throw new Error(`Missing adapter or agentId for character index ${i}`);
+    }
+    const list2 = adapterToAgentIds.get(adapter2) ?? [];
+    list2.push(agentId);
+    adapterToAgentIds.set(adapter2, list2);
+  }
+  const agentIdToRecord = new Map;
+  for (const [adapter2, ids] of adapterToAgentIds) {
+    const agents = await adapter2.getAgentsByIds(ids);
+    for (const agent2 of agents) {
+      if (agent2?.id)
+        agentIdToRecord.set(agent2.id, agent2);
+    }
+  }
+  const mergedCharacters = characters.map((c, i) => {
+    const agentId = agentIds[i];
+    if (!agentId) {
+      throw new Error(`Missing agentId for character index ${i}`);
+    }
+    const record = agentIdToRecord.get(agentId) ?? null;
+    return mergeSettingsInto(c, record);
+  });
+  const runtimes = mergedCharacters.map((char, i) => {
+    const adapter2 = adapters[i];
+    if (!adapter2) {
+      throw new Error(`Missing adapter for character index ${i}`);
+    }
+    return new AgentRuntime({
+      character: char,
+      adapter: adapter2,
+      plugins: resolvedPlugins,
+      logLevel: options?.logLevel,
+      settings: options?.settings
+    });
+  });
+  await Promise.all(runtimes.map((r) => r.initialize()));
+  if (options?.provision) {
+    const seenAdaptersForMigrations = new Set;
+    for (const r of runtimes) {
+      const adapter2 = r.adapter;
+      if (adapter2 && !seenAdaptersForMigrations.has(adapter2)) {
+        seenAdaptersForMigrations.add(adapter2);
+        await runPluginMigrations(r);
+      }
+    }
+    for (const r of runtimes) {
+      await ensureAgentInfrastructure(r);
+      await ensureEmbeddingDimension(r);
+    }
+  }
+  return runtimes;
 }
 // src/schemas/index.ts
 init_schemas();
@@ -102437,7 +101495,7 @@ class ApprovalService extends Service {
   }
 }
 async function requestConfirmation(runtime2, params) {
-  const service3 = runtime2.getService(ServiceType2.APPROVAL);
+  const service3 = await runtime2.getService(ServiceType2.APPROVAL);
   if (!service3) {
     logger.warn("ApprovalService not available, auto-denying");
     return false;
@@ -104457,16 +103515,16 @@ class PairingService extends Service {
 // src/services/pairing-integration.ts
 init_pairing();
 init_service();
-function getPairingService(runtime2) {
+async function getPairingService(runtime2) {
   try {
-    return runtime2.getService(ServiceType2.PAIRING);
+    return await runtime2.getService(ServiceType2.PAIRING);
   } catch {
     return null;
   }
 }
 async function checkPairingAllowed(runtime2, params) {
   const { channel, senderId, metadata, suppressReply } = params;
-  const pairingService = getPairingService(runtime2);
+  const pairingService = await getPairingService(runtime2);
   if (!pairingService) {
     runtime2.logger.warn({ src: "pairing-integration", channel }, "PairingService not available, allowing message by default");
     return { allowed: true };
@@ -104514,7 +103572,7 @@ function buildPairingReplyMessage(params) {
 `);
 }
 async function addToAllowlist(runtime2, channel, senderId, metadata) {
-  const pairingService = getPairingService(runtime2);
+  const pairingService = await getPairingService(runtime2);
   if (!pairingService) {
     runtime2.logger.warn({ src: "pairing-integration", channel }, "PairingService not available");
     return false;
@@ -104523,21 +103581,21 @@ async function addToAllowlist(runtime2, channel, senderId, metadata) {
   return true;
 }
 async function removeFromAllowlist(runtime2, channel, senderId) {
-  const pairingService = getPairingService(runtime2);
+  const pairingService = await getPairingService(runtime2);
   if (!pairingService) {
     return false;
   }
   return pairingService.removeFromAllowlist(channel, senderId);
 }
 async function isInAllowlist(runtime2, channel, senderId) {
-  const pairingService = getPairingService(runtime2);
+  const pairingService = await getPairingService(runtime2);
   if (!pairingService) {
     return false;
   }
   return pairingService.isAllowed(channel, senderId);
 }
 async function approvePairingCode(runtime2, channel, code2) {
-  const pairingService = getPairingService(runtime2);
+  const pairingService = await getPairingService(runtime2);
   if (!pairingService) {
     return null;
   }
@@ -104561,9 +103619,9 @@ function isExpired(request, now, ttlMs) {
     return true;
   return now.getTime() - createdAt.getTime() > ttlMs;
 }
-function getPairingService2(runtime2) {
+async function getPairingService2(runtime2) {
   try {
-    return runtime2.getService(ServiceType2.PAIRING);
+    return await runtime2.getService(ServiceType2.PAIRING);
   } catch {
     return null;
   }
@@ -104575,7 +103633,7 @@ async function migrateChannelPairingData(runtime2, channel, pairingData, allowli
     allowlistEntriesMigrated: 0,
     errors: []
   };
-  const pairingService = getPairingService2(runtime2);
+  const pairingService = await getPairingService2(runtime2);
   if (!pairingService) {
     result.errors.push("PairingService not available");
     return result;
@@ -106527,6 +105585,7 @@ export {
   runWithStreamingContext,
   runPreRegisterHooks,
   runPostRegisterHooks,
+  runPluginMigrations,
   runNonInteractiveOnboarding,
   roomSchema,
   roleProvider,
@@ -106588,6 +105647,7 @@ export {
   readSessionUpdatedAt,
   readPackageManifest,
   randomBytes,
+  provisionAgent,
   providersProvider,
   exports_proto as proto,
   processAttachments,
@@ -106637,8 +105697,10 @@ export {
   messageExampleGroupSchema,
   messageClassifierTemplate,
   mergeToolPolicies,
+  mergeSettingsInto,
   mergeSessionEntry,
   mergeHybridResults,
+  mergeDbSettings,
   mergeCharacterSecrets,
   mergeCharacterDefaults,
   memorySchema,
@@ -106666,6 +105728,7 @@ export {
   loadPluginManifest,
   loadPlugin,
   loadEnvFile,
+  loadCharacters,
   loadCharacterTs,
   loadCharacterJson,
   loadCharacterFile,
@@ -106776,6 +105839,7 @@ export {
   getCharactersDir,
   getCharacterSecret,
   getCharacterPaths,
+  getBootstrapSettings,
   getBooleanEnv,
   getAllSecretsForChannel,
   getAllElizaPaths,
@@ -106818,6 +105882,10 @@ export {
   entitiesProvider,
   ensureSafeSessionPath,
   ensureEncryptionSalt,
+  ensureEmbeddingDimension,
+  ensureConnections,
+  ensureConnection,
+  ensureAgentInfrastructure,
   encryptedCharacter,
   encryptStringValue,
   encryptObjectValues,
@@ -106852,6 +105920,7 @@ export {
   createService,
   createSendPolicyProvider,
   createSecretsRedactor,
+  createRuntimes,
   createPluginFilterHook,
   createPinnedLookup,
   createOnboardingStateMachine,
@@ -106987,7 +106056,7 @@ export {
   ServiceBuilder,
   Service,
   ServerHealthError,
-  Semaphore2 as Semaphore,
+  Semaphore,
   STANDARD_OPTIONS,
   SOCKET_MESSAGE_TYPE,
   SHOULD_UNMUTE_ROOM_TEMPLATE,
@@ -107103,5 +106172,5 @@ export {
   ADD_CONTACT_TEMPLATE
 };
 
-//# debugId=365C1C6680C0DFED64756E2164756E21
+//# debugId=505860FDDB63A26A64756E2164756E21
 //# sourceMappingURL=index.node.js.map