@elizaos/plugin-inmemorydb 2.0.0-alpha.6 → 2.0.0-beta.1

package/dist/node/index.js

@@ -1,15 +1,16 @@
-// typescript/index.ts
+// index.ts
 import {
   logger as logger2
 } from "@elizaos/core";
 
-// typescript/adapter.ts
+// adapter.ts
+import { randomUUID } from "node:crypto";
 import {
   DatabaseAdapter,
   logger
 } from "@elizaos/core";
 
-// typescript/hnsw.ts
+// hnsw.ts
 function cosineDistance(a, b) {
   if (a.length !== b.length) {
     throw new Error(`Vector dimension mismatch: ${a.length} vs ${b.length}`);
@@ -18,9 +19,11 @@ function cosineDistance(a, b) {
   let normA = 0;
   let normB = 0;
   for (let i = 0;i < a.length; i++) {
-    dotProduct += a[i] * b[i];
-    normA += a[i] * a[i];
-    normB += b[i] * b[i];
+    const aValue = a[i] ?? 0;
+    const bValue = b[i] ?? 0;
+    dotProduct += aValue * bValue;
+    normA += aValue * aValue;
+    normB += bValue * bValue;
   }
   const magnitude = Math.sqrt(normA) * Math.sqrt(normB);
   if (magnitude === 0)
@@ -105,7 +108,10 @@ class EphemeralHNSW {
         }
       }
       if (neighbors.length > 0) {
-        currentNode = neighbors[0].id;
+        const closestNeighbor = neighbors[0];
+        if (closestNeighbor) {
+          currentNode = closestNeighbor.id;
+        }
       }
     }
     this.nodes.set(id, newNode);
@@ -131,6 +137,8 @@ class EphemeralHNSW {
         break;
       results.sort((a, b) => b.distance - a.distance);
       const furthestResult = results[0];
+      if (!furthestResult)
+        break;
       if (current.distance > furthestResult.distance) {
         break;
       }
@@ -216,8 +224,9 @@ class EphemeralHNSW {
     let currentNode = this.entryPoint;
     for (let l = this.maxLevel;l > 0; l--) {
       const closest = this.searchLayer(query, currentNode, 1, l);
-      if (closest.length > 0) {
-        currentNode = closest[0].id;
+      const closestNode = closest[0];
+      if (closestNode) {
+        currentNode = closestNode.id;
       }
     }
     const results = this.searchLayer(query, currentNode, Math.max(k, this.config.efSearch), 0);
@@ -237,7 +246,7 @@ class EphemeralHNSW {
   }
 }
 
-// typescript/types.ts
+// types.ts
 var COLLECTIONS = {
   AGENTS: "agents",
   ENTITIES: "entities",
@@ -255,7 +264,7 @@ var COLLECTIONS = {
   PAIRING_ALLOWLIST: "pairing_allowlist"
 };
 
-// typescript/adapter.ts
+// adapter.ts
 function toMemory(stored) {
   return {
     id: stored.id,
@@ -271,8 +280,80 @@ function toMemory(stored) {
     metadata: stored.metadata
   };
 }
-function toMemories(stored) {
-  return stored.map(toMemory);
+function relationshipFromStored(r, fallbackAgentId) {
+  return {
+    id: r.id,
+    sourceEntityId: r.sourceEntityId,
+    targetEntityId: r.targetEntityId,
+    agentId: r.agentId ?? fallbackAgentId,
+    tags: r.tags ?? [],
+    metadata: r.metadata ?? {},
+    createdAt: r.createdAt
+  };
+}
+function applyPatchOp(target, op) {
+  if (!op.path)
+    return;
+  const parts = op.path.split(".");
+  const last = parts.pop();
+  if (last === undefined)
+    return;
+  let parent = target;
+  for (const segment of parts) {
+    const next = parent[segment];
+    if (next === null || typeof next !== "object") {
+      const created = {};
+      parent[segment] = created;
+      parent = created;
+    } else {
+      parent = next;
+    }
+  }
+  switch (op.op) {
+    case "set":
+      parent[last] = op.value;
+      break;
+    case "remove":
+      delete parent[last];
+      break;
+    case "push": {
+      const existing = parent[last];
+      if (Array.isArray(existing)) {
+        existing.push(op.value);
+      } else {
+        parent[last] = [op.value];
+      }
+      break;
+    }
+    case "increment": {
+      const existing = parent[last];
+      const delta = typeof op.value === "number" ? op.value : 1;
+      parent[last] = typeof existing === "number" ? existing + delta : delta;
+      break;
+    }
+  }
+}
+function levenshtein(a, b) {
+  if (a === b)
+    return 0;
+  if (a.length === 0)
+    return b.length;
+  if (b.length === 0)
+    return a.length;
+  const prev = new Array(b.length + 1);
+  const curr = new Array(b.length + 1);
+  for (let j = 0;j <= b.length; j++)
+    prev[j] = j;
+  for (let i = 1;i <= a.length; i++) {
+    curr[0] = i;
+    for (let j = 1;j <= b.length; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      curr[j] = Math.min(curr[j - 1] + 1, prev[j] + 1, prev[j - 1] + cost);
+    }
+    for (let j = 0;j <= b.length; j++)
+      prev[j] = curr[j];
+  }
+  return curr[b.length];
 }
 
 class InMemoryDatabaseAdapter extends DatabaseAdapter {
@@ -288,15 +369,15 @@ class InMemoryDatabaseAdapter extends DatabaseAdapter {
     this.db = storage;
     this.vectorIndex = new EphemeralHNSW;
   }
-  async initialize() {
-    await this.init();
-  }
-  async init() {
+  async initialize(_config) {
     await this.storage.init();
     await this.vectorIndex.init(this.embeddingDimension);
     this.ready = true;
     logger.info({ src: "plugin:inmemorydb" }, "In-memory database initialized");
   }
+  async init() {
+    await this.initialize();
+  }
   async runPluginMigrations(_plugins, _options) {
     logger.debug({ src: "plugin:inmemorydb" }, "Plugin migrations not needed for in-memory storage");
   }
@@ -312,30 +393,8 @@ class InMemoryDatabaseAdapter extends DatabaseAdapter {
   async getConnection() {
     return this.storage;
   }
-  async getAgent(agentId) {
-    return this.storage.get(COLLECTIONS.AGENTS, agentId);
-  }
-  async getAgents() {
-    return this.storage.getAll(COLLECTIONS.AGENTS);
-  }
-  async createAgent(agent) {
-    if (!agent.id)
-      return false;
-    await this.storage.set(COLLECTIONS.AGENTS, agent.id, agent);
-    return true;
-  }
-  async updateAgent(agentId, agent) {
-    const existing = await this.getAgent(agentId);
-    if (!existing)
-      return false;
-    await this.storage.set(COLLECTIONS.AGENTS, agentId, {
-      ...existing,
-      ...agent
-    });
-    return true;
-  }
-  async deleteAgent(agentId) {
-    return this.storage.delete(COLLECTIONS.AGENTS, agentId);
+  async transaction(callback, _options) {
+    return callback(this);
   }
   async ensureEmbeddingDimension(dimension) {
     if (this.embeddingDimension !== dimension) {
@@ -343,6 +402,26 @@ class InMemoryDatabaseAdapter extends DatabaseAdapter {
       await this.vectorIndex.init(dimension);
     }
   }
+  async createEntities(entities) {
+    const ids = [];
+    for (const entity of entities) {
+      const id = entity.id ?? randomUUID();
+      await this.storage.set(COLLECTIONS.ENTITIES, id, { ...entity, id });
+      ids.push(id);
+    }
+    return ids;
+  }
+  async upsertEntities(entities) {
+    for (const entity of entities) {
+      if (!entity.id)
+        continue;
+      const existing = await this.storage.get(COLLECTIONS.ENTITIES, entity.id);
+      await this.storage.set(COLLECTIONS.ENTITIES, entity.id, {
+        ...existing ?? {},
+        ...entity
+      });
+    }
+  }
   async getEntitiesByIds(entityIds) {
     const entities = [];
     for (const id of entityIds) {
@@ -350,57 +429,187 @@ class InMemoryDatabaseAdapter extends DatabaseAdapter {
       if (entity)
         entities.push(entity);
     }
-    return entities.length > 0 ? entities : null;
+    return entities;
   }
-  async getEntitiesForRoom(roomId, includeComponents = false) {
-    const participants = await this.storage.getWhere(COLLECTIONS.PARTICIPANTS, (p) => p.roomId === roomId);
-    const entityIds = participants.map((p) => p.entityId);
-    const entities = [];
-    for (const entityId of entityIds) {
-      const entity = await this.storage.get(COLLECTIONS.ENTITIES, entityId);
-      if (entity) {
-        if (includeComponents) {
-          const components = await this.getComponents(entityId);
+  async updateEntities(entities) {
+    for (const entity of entities) {
+      if (!entity.id)
+        continue;
+      const existing = await this.storage.get(COLLECTIONS.ENTITIES, entity.id);
+      if (!existing)
+        continue;
+      await this.storage.set(COLLECTIONS.ENTITIES, entity.id, {
+        ...existing,
+        ...entity
+      });
+    }
+  }
+  async deleteEntities(entityIds) {
+    for (const id of entityIds) {
+      await this.storage.delete(COLLECTIONS.ENTITIES, id);
+    }
+  }
+  async getEntitiesForRooms(roomIds, includeComponents = false) {
+    const result = [];
+    for (const roomId of roomIds) {
+      const participants = await this.storage.getWhere(COLLECTIONS.PARTICIPANTS, (p) => p.roomId === roomId);
+      const entityIds = [...new Set(participants.map((p) => p.entityId))];
+      const entities = await this.getEntitiesByIds(entityIds);
+      if (includeComponents) {
+        for (const entity of entities) {
+          if (!entity.id)
+            continue;
+          const components = await this.getComponentsForEntities([entity.id]);
           entity.components = components;
         }
-        entities.push(entity);
+      }
+      result.push({ roomId, entities });
+    }
+    return result;
+  }
+  async getEntitiesByNames(params) {
+    if (params.names.length === 0)
+      return [];
+    const set = new Set(params.names);
+    return this.storage.getWhere(COLLECTIONS.ENTITIES, (e) => {
+      const names = e.names ?? [];
+      return names.some((name) => set.has(name));
+    });
+  }
+  async searchEntitiesByName(params) {
+    const q = params.query.toLowerCase();
+    const matches = await this.storage.getWhere(COLLECTIONS.ENTITIES, (e) => {
+      const names = e.names ?? [];
+      return names.some((name) => name.toLowerCase().includes(q));
+    });
+    return params.limit ? matches.slice(0, params.limit) : matches;
+  }
+  async queryEntities(params) {
+    let entityIds;
+    if (params.entityIds && params.entityIds.length > 0) {
+      entityIds = params.entityIds;
+    } else {
+      const allComponents = await this.storage.getWhere(COLLECTIONS.COMPONENTS, (c) => {
+        if (params.componentType && c.type !== params.componentType)
+          return false;
+        if (params.worldId && c.worldId !== params.worldId)
+          return false;
+        if (params.componentDataFilter) {
+          const data = c.data;
+          if (!data || typeof data !== "object")
+            return false;
+          for (const [k, v] of Object.entries(params.componentDataFilter)) {
+            if (data[k] !== v)
+              return false;
+          }
+        }
+        return true;
+      });
+      entityIds = [...new Set(allComponents.map((c) => c.entityId))];
+    }
+    const offset = params.offset ?? 0;
+    const limit = params.limit;
+    const sliced = limit !== undefined ? entityIds.slice(offset, offset + limit) : entityIds.slice(offset);
+    const entities = await this.getEntitiesByIds(sliced);
+    if (params.includeAllComponents) {
+      for (const entity of entities) {
+        if (!entity.id)
+          continue;
+        const components = await this.getComponentsForEntities([entity.id]);
+        entity.components = components;
       }
     }
     return entities;
   }
-  async createEntities(entities) {
-    for (const entity of entities) {
-      if (!entity.id)
-        continue;
-      await this.storage.set(COLLECTIONS.ENTITIES, entity.id, entity);
+  async createComponents(components) {
+    const ids = [];
+    for (const component of components) {
+      const id = component.id ?? randomUUID();
+      await this.storage.set(COLLECTIONS.COMPONENTS, id, { ...component, id });
+      ids.push(id);
     }
-    return true;
+    return ids;
   }
-  async updateEntity(entity) {
-    if (!entity.id)
-      return;
-    await this.storage.set(COLLECTIONS.ENTITIES, entity.id, entity);
+  async getComponentsByIds(componentIds) {
+    const components = [];
+    for (const id of componentIds) {
+      const c = await this.storage.get(COLLECTIONS.COMPONENTS, id);
+      if (c)
+        components.push(c);
+    }
+    return components;
   }
-  async getComponent(entityId, type, worldId, sourceEntityId) {
-    const components = await this.storage.getWhere(COLLECTIONS.COMPONENTS, (c) => c.entityId === entityId && c.type === type && (worldId === undefined || c.worldId === worldId) && (sourceEntityId === undefined || c.sourceEntityId === sourceEntityId));
-    return components[0] ?? null;
+  async updateComponents(components) {
+    for (const component of components) {
+      if (!component.id)
+        continue;
+      const existing = await this.storage.get(COLLECTIONS.COMPONENTS, component.id);
+      if (!existing)
+        continue;
+      await this.storage.set(COLLECTIONS.COMPONENTS, component.id, {
+        ...existing,
+        ...component
+      });
+    }
   }
-  async getComponents(entityId, worldId, sourceEntityId) {
-    return this.storage.getWhere(COLLECTIONS.COMPONENTS, (c) => c.entityId === entityId && (worldId === undefined || c.worldId === worldId) && (sourceEntityId === undefined || c.sourceEntityId === sourceEntityId));
+  async deleteComponents(componentIds) {
+    for (const id of componentIds) {
+      await this.storage.delete(COLLECTIONS.COMPONENTS, id);
+    }
   }
-  async createComponent(component) {
-    if (!component.id)
-      return false;
-    await this.storage.set(COLLECTIONS.COMPONENTS, component.id, component);
-    return true;
+  async upsertComponents(components, _options) {
+    for (const component of components) {
+      const naturalKey = await this.storage.getWhere(COLLECTIONS.COMPONENTS, (c) => c.entityId === component.entityId && c.type === component.type && (c.worldId ?? null) === (component.worldId ?? null) && (c.sourceEntityId ?? null) === (component.sourceEntityId ?? null));
+      const existing = naturalKey[0];
+      if (existing) {
+        await this.storage.set(COLLECTIONS.COMPONENTS, existing.id, {
+          ...existing,
+          ...component,
+          id: existing.id
+        });
+      } else {
+        const id = component.id ?? randomUUID();
+        await this.storage.set(COLLECTIONS.COMPONENTS, id, {
+          ...component,
+          id
+        });
+      }
+    }
   }
-  async updateComponent(component) {
-    if (!component.id)
-      return;
-    await this.storage.set(COLLECTIONS.COMPONENTS, component.id, component);
+  async patchComponents(updates, _options) {
+    for (const update of updates) {
+      const component = await this.storage.get(COLLECTIONS.COMPONENTS, update.componentId);
+      if (!component)
+        continue;
+      const data = { ...component.data ?? {} };
+      for (const op of update.ops) {
+        applyPatchOp(data, op);
+      }
+      component.data = data;
+      await this.storage.set(COLLECTIONS.COMPONENTS, update.componentId, component);
+    }
+  }
+  async getComponentsByNaturalKeys(keys) {
+    const result = [];
+    for (const key of keys) {
+      const matches = await this.storage.getWhere(COLLECTIONS.COMPONENTS, (c) => c.entityId === key.entityId && c.type === key.type && (c.worldId ?? null) === (key.worldId ?? null) && (c.sourceEntityId ?? null) === (key.sourceEntityId ?? null));
+      result.push(matches[0] ?? null);
+    }
+    return result;
   }
-  async deleteComponent(componentId) {
-    await this.storage.delete(COLLECTIONS.COMPONENTS, componentId);
+  async getComponentsForEntities(entityIds, worldId, sourceEntityId) {
+    if (entityIds.length === 0)
+      return [];
+    const idSet = new Set(entityIds);
+    return this.storage.getWhere(COLLECTIONS.COMPONENTS, (c) => {
+      if (!idSet.has(c.entityId))
+        return false;
+      if (worldId !== undefined && c.worldId !== worldId)
+        return false;
+      if (sourceEntityId !== undefined && c.sourceEntityId !== sourceEntityId)
+        return false;
+      return true;
+    });
   }
   async getMemories(params) {
     let memories = await this.storage.getWhere(COLLECTIONS.MEMORIES, (m) => {
@@ -420,108 +629,66 @@ class InMemoryDatabaseAdapter extends DatabaseAdapter {
         return false;
       if (params.unique && !m.unique)
         return false;
+      if (params.metadata) {
+        const md = m.metadata ?? {};
+        for (const [k, v] of Object.entries(params.metadata)) {
+          if (md[k] !== v)
+            return false;
+        }
+      }
       return true;
     });
     memories.sort((a, b) => (b.createdAt ?? 0) - (a.createdAt ?? 0));
-    if (params.offset) {
-      memories = memories.slice(params.offset);
-    }
-    if (params.count) {
-      memories = memories.slice(0, params.count);
-    }
-    return toMemories(memories);
+    const offset = params.offset ?? 0;
+    const limit = params.limit ?? params.count;
+    if (offset > 0)
+      memories = memories.slice(offset);
+    if (limit !== undefined)
+      memories = memories.slice(0, limit);
+    return memories.map(toMemory);
   }
   async getMemoriesByRoomIds(params) {
-    const memories = await this.storage.getWhere(COLLECTIONS.MEMORIES, (m) => params.roomIds.includes(m.roomId) && (params.tableName ? m.metadata?.type === params.tableName : true));
+    if (params.roomIds.length === 0)
+      return [];
+    const roomSet = new Set(params.roomIds);
+    const memories = await this.storage.getWhere(COLLECTIONS.MEMORIES, (m) => roomSet.has(m.roomId) && (params.tableName ? m.metadata?.type === params.tableName : true));
     memories.sort((a, b) => (b.createdAt ?? 0) - (a.createdAt ?? 0));
-    if (params.limit) {
-      return toMemories(memories.slice(0, params.limit));
-    }
-    return toMemories(memories);
-  }
-  async getMemoryById(id) {
-    return this.storage.get(COLLECTIONS.MEMORIES, id);
+    const sliced = params.limit ? memories.slice(0, params.limit) : memories;
+    return sliced.map(toMemory);
   }
   async getMemoriesByIds(memoryIds, tableName) {
     const memories = [];
     for (const id of memoryIds) {
-      const memory = await this.storage.get(COLLECTIONS.MEMORIES, id);
-      if (memory) {
-        if (tableName && memory.metadata?.type !== tableName)
-          continue;
-        memories.push(toMemory(memory));
-      }
+      const m = await this.storage.get(COLLECTIONS.MEMORIES, id);
+      if (!m)
+        continue;
+      if (tableName && m.metadata?.type !== tableName)
+        continue;
+      memories.push(toMemory(m));
     }
     return memories;
   }
   async getCachedEmbeddings(params) {
-    const memories = await this.storage.getWhere(COLLECTIONS.MEMORIES, (m) => m.metadata?.type === params.query_table_name);
+    const memories = await this.storage.getWhere(COLLECTIONS.MEMORIES, (m) => m.metadata?.type === params.query_table_name && !!m.embedding);
     const results = [];
     for (const memory of memories) {
       if (!memory.embedding)
         continue;
-      const memoryRecord = memory;
-      const fieldValue = memoryRecord[params.query_field_name];
-      const content = String(fieldValue ?? "");
-      const score = this.simpleStringScore(params.query_input, content);
+      const record = memory;
+      const fieldValue = record[params.query_field_name];
+      const text = String(fieldValue ?? "");
+      const score = levenshtein(params.query_input, text);
       if (score <= params.query_threshold) {
-        results.push({
-          embedding: memory.embedding,
-          levenshtein_score: score
-        });
+        results.push({ embedding: memory.embedding, levenshtein_score: score });
       }
     }
+    results.sort((a, b) => a.levenshtein_score - b.levenshtein_score);
     return results.slice(0, params.query_match_count);
   }
-  simpleStringScore(a, b) {
-    if (a === b)
-      return 0;
-    const aLower = a.toLowerCase();
-    const bLower = b.toLowerCase();
-    if (aLower === bLower)
-      return 0.1;
-    if (aLower.includes(bLower) || bLower.includes(aLower))
-      return 0.3;
-    return 1;
-  }
-  async log(params) {
-    const id = crypto.randomUUID();
-    const log = {
-      id,
-      entityId: params.entityId,
-      roomId: params.roomId,
-      body: params.body,
-      type: params.type,
-      createdAt: new Date
-    };
-    await this.storage.set(COLLECTIONS.LOGS, id, log);
-  }
-  async getLogs(params) {
-    let logs = await this.storage.getWhere(COLLECTIONS.LOGS, (l) => {
-      if (params.entityId && l.entityId !== params.entityId)
-        return false;
-      if (params.roomId && l.roomId !== params.roomId)
-        return false;
-      if (params.type && l.type !== params.type)
-        return false;
-      return true;
-    });
-    logs.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
-    if (params.offset) {
-      logs = logs.slice(params.offset);
-    }
-    if (params.count) {
-      logs = logs.slice(0, params.count);
-    }
-    return logs;
-  }
-  async deleteLog(logId) {
-    await this.storage.delete(COLLECTIONS.LOGS, logId);
-  }
   async searchMemories(params) {
     const threshold = params.match_threshold ?? 0.5;
-    const count = params.count ?? 10;
-    const results = await this.vectorIndex.search(params.embedding, count * 2, threshold);
+    const limit = params.limit ?? 10;
+    const results = await this.vectorIndex.search(params.embedding, limit * 2, threshold);
     const memories = [];
     for (const result of results) {
       const memory = await this.storage.get(COLLECTIONS.MEMORIES, result.id);
@@ -537,101 +704,223 @@ class InMemoryDatabaseAdapter extends DatabaseAdapter {
         continue;
       if (params.unique && !memory.unique)
         continue;
-      memories.push({
-        ...toMemory(memory),
-        similarity: result.similarity
-      });
+      memories.push({ ...toMemory(memory), similarity: result.similarity });
     }
-    return memories.slice(0, count);
+    return memories.slice(0, limit);
   }
-  async createMemory(memory, tableName, unique = false) {
-    const id = memory.id ?? crypto.randomUUID();
-    const now = Date.now();
-    const storedMemory = {
-      ...memory,
-      id,
-      agentId: memory.agentId ?? this.agentId,
-      unique: unique || memory.unique,
-      createdAt: memory.createdAt ?? now,
-      metadata: {
-        ...memory.metadata ?? {},
-        type: tableName
+  async createMemories(memories) {
+    const ids = [];
+    for (const { memory, tableName, unique = false } of memories) {
+      const id = memory.id ?? randomUUID();
+      const stored = {
+        ...memory,
+        id,
+        agentId: memory.agentId ?? this.agentId,
+        unique: unique || memory.unique,
+        createdAt: memory.createdAt ?? Date.now(),
+        metadata: {
+          ...memory.metadata ?? {},
+          type: tableName
+        }
+      };
+      await this.storage.set(COLLECTIONS.MEMORIES, id, stored);
+      if (memory.embedding && memory.embedding.length > 0) {
+        await this.vectorIndex.add(id, memory.embedding);
       }
-    };
-    await this.storage.set(COLLECTIONS.MEMORIES, id, storedMemory);
-    if (memory.embedding && memory.embedding.length > 0) {
-      await this.vectorIndex.add(id, memory.embedding);
-    }
-    return id;
-  }
-  async updateMemory(memory) {
-    const existing = await this.getMemoryById(memory.id);
-    if (!existing)
-      return false;
-    const updated = {
-      ...existing,
-      ...memory,
-      metadata: {
-        ...existing.metadata ?? {},
-        ...memory.metadata ?? {}
+      ids.push(id);
+    }
+    return ids;
+  }
+  async updateMemories(memories) {
+    for (const memory of memories) {
+      const existing = await this.storage.get(COLLECTIONS.MEMORIES, memory.id);
+      if (!existing)
+        continue;
+      const updated = {
+        ...existing,
+        ...memory,
+        metadata: {
+          ...existing.metadata ?? {},
+          ...memory.metadata ?? {}
+        }
+      };
+      await this.storage.set(COLLECTIONS.MEMORIES, memory.id, updated);
+      if (memory.embedding && memory.embedding.length > 0) {
+        await this.vectorIndex.add(memory.id, memory.embedding);
       }
-    };
-    await this.storage.set(COLLECTIONS.MEMORIES, memory.id, updated);
-    if (memory.embedding && memory.embedding.length > 0) {
-      await this.vectorIndex.add(memory.id, memory.embedding);
     }
-    return true;
   }
-  async deleteMemory(memoryId) {
-    await this.storage.delete(COLLECTIONS.MEMORIES, memoryId);
-    await this.vectorIndex.remove(memoryId);
+  async upsertMemories(memories, _options) {
+    for (const { memory, tableName } of memories) {
+      if (!memory.id) {
+        await this.createMemories([{ memory, tableName }]);
+        continue;
+      }
+      const existing = await this.storage.get(COLLECTIONS.MEMORIES, memory.id);
+      const stored = {
+        ...existing ?? {},
+        ...memory,
+        agentId: memory.agentId ?? existing?.agentId ?? this.agentId,
+        createdAt: memory.createdAt ?? existing?.createdAt ?? Date.now(),
+        metadata: {
+          ...existing?.metadata ?? {},
+          ...memory.metadata ?? {},
+          type: tableName
+        }
+      };
+      await this.storage.set(COLLECTIONS.MEMORIES, memory.id, stored);
+      if (memory.embedding && memory.embedding.length > 0) {
+        await this.vectorIndex.add(memory.id, memory.embedding);
+      }
+    }
   }
-  async deleteManyMemories(memoryIds) {
+  async deleteMemories(memoryIds) {
     for (const id of memoryIds) {
-      await this.deleteMemory(id);
+      await this.storage.delete(COLLECTIONS.MEMORIES, id);
+      await this.vectorIndex.remove(id);
     }
   }
-  async deleteAllMemories(roomId, tableName) {
-    const memories = await this.getMemories({ roomId, tableName });
-    await this.deleteManyMemories(memories.map((m) => m.id).filter((id) => id !== undefined));
-  }
-  async countMemories(roomId, unique = false, tableName) {
-    return this.storage.count(COLLECTIONS.MEMORIES, (memory) => {
-      if (memory.roomId !== roomId)
+  async deleteAllMemories(roomIds, tableName) {
+    if (roomIds.length === 0)
+      return;
+    const roomSet = new Set(roomIds);
+    const memories = await this.storage.getWhere(COLLECTIONS.MEMORIES, (m) => roomSet.has(m.roomId) && (tableName ? m.metadata?.type === tableName : true));
+    const ids = memories.map((m) => m.id).filter((id) => id !== undefined);
+    await this.deleteMemories(ids);
+  }
+  async countMemories(params) {
+    const roomSet = params.roomIds ? new Set(params.roomIds) : null;
+    return this.storage.count(COLLECTIONS.MEMORIES, (m) => {
+      if (roomSet && !roomSet.has(m.roomId))
         return false;
-      if (unique && !memory.unique)
+      if (params.unique && !m.unique)
         return false;
-      if (tableName && memory.metadata?.type !== tableName)
+      if (params.tableName && m.metadata?.type !== params.tableName)
         return false;
+      if (params.entityId && m.entityId !== params.entityId)
+        return false;
+      if (params.agentId && m.agentId !== params.agentId)
+        return false;
+      if (params.metadata) {
+        const md = m.metadata ?? {};
+        for (const [k, v] of Object.entries(params.metadata)) {
+          if (md[k] !== v)
+            return false;
+        }
+      }
       return true;
     });
   }
   async getMemoriesByWorldId(params) {
-    const memories = await this.storage.getWhere(COLLECTIONS.MEMORIES, (m) => m.worldId === params.worldId && (params.tableName ? m.metadata?.type === params.tableName : true));
+    const worldSet = params.worldIds ? new Set(params.worldIds) : null;
+    const memories = await this.storage.getWhere(COLLECTIONS.MEMORIES, (m) => (!worldSet || (m.worldId ? worldSet.has(m.worldId) : false)) && (params.tableName ? m.metadata?.type === params.tableName : true));
     memories.sort((a, b) => (b.createdAt ?? 0) - (a.createdAt ?? 0));
-    if (params.count) {
-      return toMemories(memories.slice(0, params.count));
+    const sliced = params.limit ? memories.slice(0, params.limit) : memories;
+    return sliced.map(toMemory);
+  }
+  async getLogs(params) {
+    let logs = await this.storage.getWhere(COLLECTIONS.LOGS, (l) => {
+      if (params.entityId && l.entityId !== params.entityId)
+        return false;
+      if (params.roomId && l.roomId !== params.roomId)
+        return false;
+      if (params.type && l.type !== params.type)
+        return false;
+      return true;
+    });
+    logs.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+    const offset = params.offset ?? 0;
+    if (offset > 0)
+      logs = logs.slice(offset);
+    if (params.limit !== undefined)
+      logs = logs.slice(0, params.limit);
+    return logs;
+  }
+  async createLogs(params) {
+    for (const entry of params) {
+      const id = randomUUID();
+      const log = {
+        id,
+        entityId: entry.entityId,
+        roomId: entry.roomId,
+        body: entry.body,
+        type: entry.type,
+        createdAt: new Date
+      };
+      await this.storage.set(COLLECTIONS.LOGS, id, log);
     }
-    return toMemories(memories);
   }
-  async createWorld(world) {
-    const id = world.id ?? crypto.randomUUID();
-    await this.storage.set(COLLECTIONS.WORLDS, id, { ...world, id });
-    return id;
+  async getLogsByIds(logIds) {
+    const logs = [];
+    for (const id of logIds) {
+      const log = await this.storage.get(COLLECTIONS.LOGS, id);
+      if (log)
+        logs.push(log);
+    }
+    return logs;
   }
-  async getWorld(id) {
-    return this.storage.get(COLLECTIONS.WORLDS, id);
+  async updateLogs(logs) {
+    for (const { id, updates } of logs) {
+      const existing = await this.storage.get(COLLECTIONS.LOGS, id);
+      if (!existing)
+        continue;
+      await this.storage.set(COLLECTIONS.LOGS, id, { ...existing, ...updates });
+    }
   }
-  async removeWorld(id) {
-    await this.storage.delete(COLLECTIONS.WORLDS, id);
+  async deleteLogs(logIds) {
+    for (const id of logIds) {
+      await this.storage.delete(COLLECTIONS.LOGS, id);
+    }
   }
   async getAllWorlds() {
     return this.storage.getAll(COLLECTIONS.WORLDS);
   }
-  async updateWorld(world) {
-    if (!world.id)
-      return;
-    await this.storage.set(COLLECTIONS.WORLDS, world.id, world);
+  async getWorldsByIds(worldIds) {
+    const worlds = [];
+    for (const id of worldIds) {
+      const w = await this.storage.get(COLLECTIONS.WORLDS, id);
+      if (w)
+        worlds.push(w);
+    }
+    return worlds;
+  }
+  async createWorlds(worlds) {
+    const ids = [];
+    for (const world of worlds) {
+      const id = world.id ?? randomUUID();
+      await this.storage.set(COLLECTIONS.WORLDS, id, { ...world, id });
+      ids.push(id);
+    }
+    return ids;
+  }
+  async deleteWorlds(worldIds) {
+    for (const id of worldIds) {
+      await this.storage.delete(COLLECTIONS.WORLDS, id);
+    }
+  }
+  async updateWorlds(worlds) {
+    for (const world of worlds) {
+      if (!world.id)
+        continue;
+      const existing = await this.storage.get(COLLECTIONS.WORLDS, world.id);
+      if (!existing)
+        continue;
+      await this.storage.set(COLLECTIONS.WORLDS, world.id, {
+        ...existing,
+        ...world
+      });
+    }
+  }
+  async upsertWorlds(worlds) {
+    for (const world of worlds) {
+      const id = world.id ?? randomUUID();
+      const existing = await this.storage.get(COLLECTIONS.WORLDS, id);
+      await this.storage.set(COLLECTIONS.WORLDS, id, {
+        ...existing ?? {},
+        ...world,
+        id
+      });
+    }
   }
   async getRoomsByIds(roomIds) {
     const rooms = [];
@@ -640,107 +929,169 @@ class InMemoryDatabaseAdapter extends DatabaseAdapter {
       if (room)
         rooms.push(room);
     }
-    return rooms.length > 0 ? rooms : null;
+    return rooms;
+  }
+  async deleteRoomsByWorldIds(worldIds) {
+    if (worldIds.length === 0)
+      return;
+    const worldSet = new Set(worldIds);
+    const rooms = await this.storage.getWhere(COLLECTIONS.ROOMS, (r) => r.worldId ? worldSet.has(r.worldId) : false);
+    const roomIds = rooms.map((r) => r.id).filter((id) => id !== undefined);
+    await this.deleteRooms(roomIds);
+  }
+  async getRoomsForParticipants(entityIds) {
+    if (entityIds.length === 0)
+      return [];
+    const entitySet = new Set(entityIds);
+    const participants = await this.storage.getWhere(COLLECTIONS.PARTICIPANTS, (p) => entitySet.has(p.entityId));
+    return [...new Set(participants.map((p) => p.roomId))];
+  }
+  async getRoomsByWorlds(worldIds, limit, offset) {
+    if (worldIds.length === 0)
+      return [];
+    const worldSet = new Set(worldIds);
+    let rooms = await this.storage.getWhere(COLLECTIONS.ROOMS, (r) => r.worldId ? worldSet.has(r.worldId) : false);
+    const off = offset ?? 0;
+    if (off > 0)
+      rooms = rooms.slice(off);
+    if (limit !== undefined)
+      rooms = rooms.slice(0, limit);
+    return rooms;
   }
   async createRooms(rooms) {
     const ids = [];
     for (const room of rooms) {
-      const id = room.id ?? crypto.randomUUID();
+      const id = room.id ?? randomUUID();
       await this.storage.set(COLLECTIONS.ROOMS, id, { ...room, id });
       ids.push(id);
     }
     return ids;
   }
-  async deleteRoom(roomId) {
-    await this.storage.delete(COLLECTIONS.ROOMS, roomId);
-    await this.storage.deleteWhere(COLLECTIONS.PARTICIPANTS, (p) => p.roomId === roomId);
-    await this.storage.deleteWhere(COLLECTIONS.MEMORIES, (m) => m.roomId === roomId);
+  async upsertRooms(rooms) {
+    for (const room of rooms) {
+      const id = room.id ?? randomUUID();
+      const existing = await this.storage.get(COLLECTIONS.ROOMS, id);
+      await this.storage.set(COLLECTIONS.ROOMS, id, {
+        ...existing ?? {},
+        ...room,
+        id
+      });
+    }
   }
-  async deleteRoomsByWorldId(worldId) {
-    const rooms = await this.getRoomsByWorld(worldId);
+  async updateRooms(rooms) {
     for (const room of rooms) {
-      if (room.id) {
-        await this.deleteRoom(room.id);
-      }
+      if (!room.id)
+        continue;
+      const existing = await this.storage.get(COLLECTIONS.ROOMS, room.id);
+      if (!existing)
+        continue;
+      await this.storage.set(COLLECTIONS.ROOMS, room.id, {
+        ...existing,
+        ...room
+      });
     }
   }
-  async updateRoom(room) {
-    if (!room.id)
+  async deleteRooms(roomIds) {
+    if (roomIds.length === 0)
       return;
-    await this.storage.set(COLLECTIONS.ROOMS, room.id, room);
-  }
-  async getRoomsForParticipant(entityId) {
-    const participants = await this.storage.getWhere(COLLECTIONS.PARTICIPANTS, (p) => p.entityId === entityId);
-    return participants.map((p) => p.roomId);
+    const set = new Set(roomIds);
+    for (const id of roomIds) {
+      await this.storage.delete(COLLECTIONS.ROOMS, id);
+    }
+    await this.storage.deleteWhere(COLLECTIONS.PARTICIPANTS, (p) => set.has(p.roomId));
+    await this.storage.deleteWhere(COLLECTIONS.MEMORIES, (m) => set.has(m.roomId));
   }
-  async getRoomsForParticipants(userIds) {
-    const participants = await this.storage.getWhere(COLLECTIONS.PARTICIPANTS, (p) => userIds.includes(p.entityId));
-    return [...new Set(participants.map((p) => p.roomId))];
+  async createRoomParticipants(entityIds, roomId) {
+    const ids = [];
+    for (const entityId of entityIds) {
+      const existing = await this.storage.getWhere(COLLECTIONS.PARTICIPANTS, (p) => p.entityId === entityId && p.roomId === roomId);
+      const existingParticipant = existing[0];
+      if (existingParticipant) {
+        ids.push(existingParticipant.id);
+        continue;
+      }
+      const id = randomUUID();
+      const participant = { id, entityId, roomId };
+      await this.storage.set(COLLECTIONS.PARTICIPANTS, id, participant);
+      ids.push(id);
+    }
+    return ids;
   }
-  async getRoomsByWorld(worldId) {
-    return this.storage.getWhere(COLLECTIONS.ROOMS, (r) => r.worldId === worldId);
+  async deleteParticipants(participants) {
+    let removed = false;
+    for (const { entityId, roomId } of participants) {
+      const matches = await this.storage.getWhere(COLLECTIONS.PARTICIPANTS, (p) => p.entityId === entityId && p.roomId === roomId);
+      for (const p of matches) {
+        if (p.id) {
+          await this.storage.delete(COLLECTIONS.PARTICIPANTS, p.id);
+          removed = true;
+        }
+      }
+    }
+    return removed;
   }
-  async removeParticipant(entityId, roomId) {
-    const participants = await this.storage.getWhere(COLLECTIONS.PARTICIPANTS, (p) => p.entityId === entityId && p.roomId === roomId);
-    if (participants.length === 0)
-      return false;
-    for (const p of participants) {
-      if (p.id) {
-        await this.storage.delete(COLLECTIONS.PARTICIPANTS, p.id);
+  async updateParticipants(participants) {
+    for (const { entityId, roomId, updates } of participants) {
+      const matches = await this.storage.getWhere(COLLECTIONS.PARTICIPANTS, (p) => p.entityId === entityId && p.roomId === roomId);
+      for (const p of matches) {
+        if (!p.id)
+          continue;
+        const next = {
+          ...p,
+          userState: updates.roomState ?? p.userState,
+          metadata: { ...p.metadata ?? {}, ...updates.metadata ?? {} }
+        };
+        await this.storage.set(COLLECTIONS.PARTICIPANTS, p.id, next);
       }
     }
-    return true;
   }
-  async getParticipantsForEntity(entityId) {
-    const stored = await this.storage.getWhere(COLLECTIONS.PARTICIPANTS, (p) => p.entityId === entityId);
+  async getParticipantsForEntities(entityIds) {
+    if (entityIds.length === 0)
+      return [];
+    const set = new Set(entityIds);
+    const stored = await this.storage.getWhere(COLLECTIONS.PARTICIPANTS, (p) => set.has(p.entityId));
     const participants = [];
     for (const p of stored) {
       const entity = await this.storage.get(COLLECTIONS.ENTITIES, p.entityId);
-      if (entity) {
-        participants.push({
-          id: p.id,
-          entity
-        });
-      }
+      if (entity)
+        participants.push({ id: p.id, entity });
     }
     return participants;
   }
-  async getParticipantsForRoom(roomId) {
-    const participants = await this.storage.getWhere(COLLECTIONS.PARTICIPANTS, (p) => p.roomId === roomId);
-    return participants.map((p) => p.entityId);
-  }
-  async isRoomParticipant(roomId, entityId) {
-    const participants = await this.storage.getWhere(COLLECTIONS.PARTICIPANTS, (p) => p.roomId === roomId && p.entityId === entityId);
-    return participants.length > 0;
+  async getParticipantsForRooms(roomIds) {
+    const result = [];
+    for (const roomId of roomIds) {
+      const stored = await this.storage.getWhere(COLLECTIONS.PARTICIPANTS, (p) => p.roomId === roomId);
+      result.push({
+        roomId,
+        entityIds: [...new Set(stored.map((p) => p.entityId))]
+      });
+    }
+    return result;
   }
-  async addParticipantsRoom(entityIds, roomId) {
-    for (const entityId of entityIds) {
-      const exists = await this.isRoomParticipant(roomId, entityId);
-      if (!exists) {
-        const id = crypto.randomUUID();
-        const participant = {
-          id,
-          entityId,
-          roomId
-        };
-        await this.storage.set(COLLECTIONS.PARTICIPANTS, id, participant);
-      }
+  async areRoomParticipants(pairs) {
+    const result = [];
+    for (const { roomId, entityId } of pairs) {
+      const matches = await this.storage.getWhere(COLLECTIONS.PARTICIPANTS, (p) => p.roomId === roomId && p.entityId === entityId);
+      result.push(matches.length > 0);
     }
-    return true;
+    return result;
+  }
+  async getParticipantUserStates(pairs) {
+    const result = [];
+    for (const { roomId, entityId } of pairs) {
+      const matches = await this.storage.getWhere(COLLECTIONS.PARTICIPANTS, (p) => p.roomId === roomId && p.entityId === entityId);
+      const state = matches[0]?.userState ?? null;
+      result.push(state);
+    }
+    return result;
   }
-  async getParticipantUserState(roomId, entityId) {
-    const participants = await this.storage.getWhere(COLLECTIONS.PARTICIPANTS, (p) => p.roomId === roomId && p.entityId === entityId);
-    if (participants.length === 0)
-      return null;
-    const state = participants[0].userState;
-    if (state === "FOLLOWED" || state === "MUTED")
-      return state;
-    return null;
-  }
-  async setParticipantUserState(roomId, entityId, state) {
-    const participants = await this.storage.getWhere(COLLECTIONS.PARTICIPANTS, (p) => p.roomId === roomId && p.entityId === entityId);
-    for (const p of participants) {
-      if (p.id) {
+  async updateParticipantUserStates(updates) {
+    for (const { roomId, entityId, state } of updates) {
+      const matches = await this.storage.getWhere(COLLECTIONS.PARTICIPANTS, (p) => p.roomId === roomId && p.entityId === entityId);
+      for (const p of matches) {
+        if (!p.id)
+          continue;
         await this.storage.set(COLLECTIONS.PARTICIPANTS, p.id, {
           ...p,
           userState: state
@@ -748,157 +1099,313 @@ class InMemoryDatabaseAdapter extends DatabaseAdapter {
       }
     }
   }
-  async createRelationship(params) {
-    const id = crypto.randomUUID();
-    const relationship = {
-      id,
-      sourceEntityId: params.sourceEntityId,
-      targetEntityId: params.targetEntityId,
-      agentId: this.agentId,
-      tags: params.tags ?? [],
-      metadata: params.metadata ?? {},
-      createdAt: new Date().toISOString()
-    };
-    await this.storage.set(COLLECTIONS.RELATIONSHIPS, id, relationship);
-    return true;
-  }
-  async getRelationship(params) {
-    const relationships = await this.storage.getWhere(COLLECTIONS.RELATIONSHIPS, (r2) => r2.sourceEntityId === params.sourceEntityId && r2.targetEntityId === params.targetEntityId);
-    if (relationships.length === 0)
-      return null;
-    const r = relationships[0];
-    return {
-      id: r.id,
-      sourceEntityId: r.sourceEntityId,
-      targetEntityId: r.targetEntityId,
-      agentId: r.agentId ?? this.agentId,
-      tags: r.tags ?? [],
-      metadata: r.metadata ?? {},
-      createdAt: r.createdAt
-    };
+  async getRelationshipsByPairs(pairs) {
+    const result = [];
+    for (const pair of pairs) {
+      const matches = await this.storage.getWhere(COLLECTIONS.RELATIONSHIPS, (r) => r.sourceEntityId === pair.sourceEntityId && r.targetEntityId === pair.targetEntityId);
+      const first = matches[0];
+      result.push(first ? relationshipFromStored(first, this.agentId) : null);
+    }
+    return result;
   }
   async getRelationships(params) {
-    const stored = await this.storage.getWhere(COLLECTIONS.RELATIONSHIPS, (r) => {
-      const isInvolved = r.sourceEntityId === params.entityId || r.targetEntityId === params.entityId;
-      if (!isInvolved)
-        return false;
+    const entitySet = params.entityIds ? new Set(params.entityIds) : null;
+    let stored = await this.storage.getWhere(COLLECTIONS.RELATIONSHIPS, (r) => {
+      if (entitySet) {
+        if (!entitySet.has(r.sourceEntityId) && !entitySet.has(r.targetEntityId)) {
+          return false;
+        }
+      }
       if (params.tags && params.tags.length > 0) {
-        return params.tags.some((tag) => r.tags?.includes(tag));
+        const tags = r.tags ?? [];
+        if (!params.tags.some((t) => tags.includes(t)))
+          return false;
       }
       return true;
     });
-    return stored.map((r) => ({
-      id: r.id,
-      sourceEntityId: r.sourceEntityId,
-      targetEntityId: r.targetEntityId,
-      agentId: r.agentId ?? this.agentId,
-      tags: r.tags ?? [],
-      metadata: r.metadata ?? {},
-      createdAt: r.createdAt
-    }));
+    const offset = params.offset ?? 0;
+    if (offset > 0)
+      stored = stored.slice(offset);
+    if (params.limit !== undefined)
+      stored = stored.slice(0, params.limit);
+    return stored.map((r) => relationshipFromStored(r, this.agentId));
+  }
+  async createRelationships(relationships) {
+    const ids = [];
+    for (const rel of relationships) {
+      const id = randomUUID();
+      const stored = {
+        id,
+        sourceEntityId: rel.sourceEntityId,
+        targetEntityId: rel.targetEntityId,
+        agentId: this.agentId,
+        tags: rel.tags ?? [],
+        metadata: rel.metadata ?? {},
+        createdAt: new Date().toISOString()
+      };
+      await this.storage.set(COLLECTIONS.RELATIONSHIPS, id, stored);
+      ids.push(id);
+    }
+    return ids;
   }
-  async updateRelationship(relationship) {
-    const existing = await this.getRelationship({
-      sourceEntityId: relationship.sourceEntityId,
-      targetEntityId: relationship.targetEntityId
-    });
-    if (!existing || !existing.id)
-      return;
-    const stored = {
-      id: existing.id,
-      sourceEntityId: relationship.sourceEntityId,
-      targetEntityId: relationship.targetEntityId,
-      agentId: relationship.agentId,
-      tags: relationship.tags ?? existing.tags ?? [],
-      metadata: { ...existing.metadata ?? {}, ...relationship.metadata ?? {} },
-      createdAt: existing.createdAt ?? new Date().toISOString()
-    };
-    await this.storage.set(COLLECTIONS.RELATIONSHIPS, existing.id, stored);
+  async getRelationshipsByIds(relationshipIds) {
+    const relationships = [];
+    for (const id of relationshipIds) {
+      const r = await this.storage.get(COLLECTIONS.RELATIONSHIPS, id);
+      if (r)
+        relationships.push(relationshipFromStored(r, this.agentId));
+    }
+    return relationships;
   }
-  async getCache(key) {
-    const cached = await this.storage.get(COLLECTIONS.CACHE, key);
-    if (!cached)
-      return;
-    if (cached.expiresAt && Date.now() > cached.expiresAt) {
-      await this.deleteCache(key);
-      return;
+  async updateRelationships(relationships) {
+    for (const rel of relationships) {
+      if (!rel.id)
+        continue;
+      const existing = await this.storage.get(COLLECTIONS.RELATIONSHIPS, rel.id);
+      if (!existing)
+        continue;
+      const next = {
+        ...existing,
+        sourceEntityId: rel.sourceEntityId ?? existing.sourceEntityId,
+        targetEntityId: rel.targetEntityId ?? existing.targetEntityId,
+        agentId: rel.agentId ?? existing.agentId,
+        tags: rel.tags ?? existing.tags,
+        metadata: { ...existing.metadata ?? {}, ...rel.metadata ?? {} }
+      };
+      await this.storage.set(COLLECTIONS.RELATIONSHIPS, rel.id, next);
     }
-    return cached.value;
   }
-  async setCache(key, value) {
-    await this.storage.set(COLLECTIONS.CACHE, key, { value });
-    return true;
+  async deleteRelationships(relationshipIds) {
+    for (const id of relationshipIds) {
+      await this.storage.delete(COLLECTIONS.RELATIONSHIPS, id);
+    }
+  }
+  async getAgents() {
+    return this.storage.getAll(COLLECTIONS.AGENTS);
+  }
+  async getAgentsByIds(agentIds) {
+    const agents = [];
+    for (const id of agentIds) {
+      const agent = await this.storage.get(COLLECTIONS.AGENTS, id);
+      if (agent)
+        agents.push(agent);
+    }
+    return agents;
+  }
+  async createAgents(agents) {
+    const ids = [];
+    for (const agent of agents) {
+      const id = agent.id ?? randomUUID();
+      await this.storage.set(COLLECTIONS.AGENTS, id, { ...agent, id });
+      ids.push(id);
+    }
+    return ids;
+  }
+  async updateAgents(updates) {
+    let updated = false;
+    for (const { agentId, agent } of updates) {
+      const existing = await this.storage.get(COLLECTIONS.AGENTS, agentId);
+      if (!existing)
+        continue;
+      await this.storage.set(COLLECTIONS.AGENTS, agentId, {
+        ...existing,
+        ...agent
+      });
+      updated = true;
+    }
+    return updated;
+  }
+  async upsertAgents(agents) {
+    for (const agent of agents) {
+      const id = agent.id ?? randomUUID();
+      const existing = await this.storage.get(COLLECTIONS.AGENTS, id);
+      await this.storage.set(COLLECTIONS.AGENTS, id, {
+        ...existing ?? {},
+        ...agent,
+        id
+      });
+    }
+  }
+  async deleteAgents(agentIds) {
+    let removed = false;
+    for (const id of agentIds) {
+      const ok = await this.storage.delete(COLLECTIONS.AGENTS, id);
+      if (ok)
+        removed = true;
+    }
+    return removed;
+  }
+  async countAgents() {
+    return this.storage.count(COLLECTIONS.AGENTS);
+  }
+  async cleanupAgents() {}
+  async getCaches(keys) {
+    const out = new Map;
+    for (const key of keys) {
+      const entry = await this.storage.get(COLLECTIONS.CACHE, key);
+      if (!entry)
+        continue;
+      if (entry.expiresAt && Date.now() > entry.expiresAt) {
+        await this.storage.delete(COLLECTIONS.CACHE, key);
+        continue;
+      }
+      out.set(key, entry.value);
+    }
+    return out;
   }
-  async deleteCache(key) {
-    return this.storage.delete(COLLECTIONS.CACHE, key);
+  async setCaches(entries) {
+    for (const { key, value } of entries) {
+      await this.storage.set(COLLECTIONS.CACHE, key, { value });
+    }
+    return true;
   }
-  async createTask(task) {
-    const id = task.id ?? crypto.randomUUID();
-    await this.storage.set(COLLECTIONS.TASKS, id, { ...task, id });
-    return id;
+  async deleteCaches(keys) {
+    let removed = false;
+    for (const key of keys) {
+      const ok = await this.storage.delete(COLLECTIONS.CACHE, key);
+      if (ok)
+        removed = true;
+    }
+    return removed;
   }
   async getTasks(params) {
-    return this.storage.getWhere(COLLECTIONS.TASKS, (t) => {
+    const agentSet = new Set(params.agentIds);
+    let tasks = await this.storage.getWhere(COLLECTIONS.TASKS, (t) => {
+      const taskAgentId = t.agentId;
+      if (agentSet.size > 0 && taskAgentId !== undefined && !agentSet.has(taskAgentId)) {
+        return false;
+      }
       if (params.roomId && t.roomId !== params.roomId)
         return false;
       if (params.entityId && t.entityId !== params.entityId)
         return false;
       if (params.tags && params.tags.length > 0) {
-        if (!t.tags?.some((tag) => params.tags?.includes(tag)))
+        const tags = t.tags ?? [];
+        if (!params.tags.some((tag) => tags.includes(tag)))
           return false;
       }
       return true;
     });
-  }
-  async getTask(id) {
-    return this.storage.get(COLLECTIONS.TASKS, id);
+    const offset = params.offset ?? 0;
+    if (offset > 0)
+      tasks = tasks.slice(offset);
+    if (params.limit !== undefined)
+      tasks = tasks.slice(0, params.limit);
+    return tasks;
   }
   async getTasksByName(name) {
     return this.storage.getWhere(COLLECTIONS.TASKS, (t) => t.name === name);
   }
-  async updateTask(id, task) {
-    const existing = await this.getTask(id);
-    if (!existing)
-      return;
-    await this.storage.set(COLLECTIONS.TASKS, id, { ...existing, ...task });
+  async createTasks(tasks) {
+    const ids = [];
+    for (const task of tasks) {
+      const id = task.id ?? randomUUID();
+      await this.storage.set(COLLECTIONS.TASKS, id, { ...task, id });
+      ids.push(id);
+    }
+    return ids;
   }
-  async deleteTask(id) {
-    await this.storage.delete(COLLECTIONS.TASKS, id);
+  async getTasksByIds(taskIds) {
+    const tasks = [];
+    for (const id of taskIds) {
+      const task = await this.storage.get(COLLECTIONS.TASKS, id);
+      if (task)
+        tasks.push(task);
+    }
+    return tasks;
   }
-  async getPairingRequests(channel, agentId) {
-    return this.storage.getWhere(COLLECTIONS.PAIRING_REQUESTS, (r) => r.channel === channel && r.agentId === agentId);
+  async updateTasks(updates) {
+    for (const { id, task } of updates) {
+      const existing = await this.storage.get(COLLECTIONS.TASKS, id);
+      if (!existing)
+        continue;
+      await this.storage.set(COLLECTIONS.TASKS, id, { ...existing, ...task });
+    }
   }
-  async createPairingRequest(request) {
-    const id = request.id ?? crypto.randomUUID();
-    await this.storage.set(COLLECTIONS.PAIRING_REQUESTS, id, { ...request, id });
-    return id;
+  async deleteTasks(taskIds) {
+    for (const id of taskIds) {
+      await this.storage.delete(COLLECTIONS.TASKS, id);
+    }
   }
-  async updatePairingRequest(request) {
-    const existing = await this.storage.get(COLLECTIONS.PAIRING_REQUESTS, request.id);
-    if (existing) {
+  async getPairingRequests(queries) {
+    const result = [];
+    for (const { channel, agentId } of queries) {
+      const requests = await this.storage.getWhere(COLLECTIONS.PAIRING_REQUESTS, (r) => r.channel === channel && r.agentId === agentId);
+      result.push({ channel, agentId, requests });
+    }
+    return result;
+  }
+  async getPairingAllowlists(queries) {
+    const result = [];
+    for (const { channel, agentId } of queries) {
+      const entries = await this.storage.getWhere(COLLECTIONS.PAIRING_ALLOWLIST, (e) => e.channel === channel && e.agentId === agentId);
+      result.push({ channel, agentId, entries });
+    }
+    return result;
+  }
+  async createPairingRequests(requests) {
+    const ids = [];
+    for (const request of requests) {
+      const id = request.id ?? randomUUID();
+      await this.storage.set(COLLECTIONS.PAIRING_REQUESTS, id, {
+        ...request,
+        id
+      });
+      ids.push(id);
+    }
+    return ids;
+  }
+  async updatePairingRequests(requests) {
+    for (const request of requests) {
+      if (!request.id)
+        continue;
+      const existing = await this.storage.get(COLLECTIONS.PAIRING_REQUESTS, request.id);
+      if (!existing)
+        continue;
       await this.storage.set(COLLECTIONS.PAIRING_REQUESTS, request.id, {
         ...existing,
         ...request
       });
     }
   }
-  async deletePairingRequest(id) {
-    await this.storage.delete(COLLECTIONS.PAIRING_REQUESTS, id);
+  async deletePairingRequests(ids) {
+    for (const id of ids) {
+      await this.storage.delete(COLLECTIONS.PAIRING_REQUESTS, id);
+    }
   }
-  async getPairingAllowlist(channel, agentId) {
-    return this.storage.getWhere(COLLECTIONS.PAIRING_ALLOWLIST, (e) => e.channel === channel && e.agentId === agentId);
+  async createPairingAllowlistEntries(entries) {
+    const ids = [];
+    for (const entry of entries) {
+      const id = entry.id ?? randomUUID();
+      await this.storage.set(COLLECTIONS.PAIRING_ALLOWLIST, id, {
+        ...entry,
+        id
+      });
+      ids.push(id);
+    }
+    return ids;
   }
-  async createPairingAllowlistEntry(entry) {
-    const id = entry.id ?? crypto.randomUUID();
-    await this.storage.set(COLLECTIONS.PAIRING_ALLOWLIST, id, { ...entry, id });
-    return id;
+  async updatePairingAllowlistEntries(entries) {
+    for (const entry of entries) {
+      if (!entry.id)
+        continue;
+      const existing = await this.storage.get(COLLECTIONS.PAIRING_ALLOWLIST, entry.id);
+      if (!existing)
+        continue;
+      await this.storage.set(COLLECTIONS.PAIRING_ALLOWLIST, entry.id, {
+        ...existing,
+        ...entry
+      });
+    }
   }
-  async deletePairingAllowlistEntry(id) {
-    await this.storage.delete(COLLECTIONS.PAIRING_ALLOWLIST, id);
+  async deletePairingAllowlistEntries(ids) {
+    for (const id of ids) {
+      await this.storage.delete(COLLECTIONS.PAIRING_ALLOWLIST, id);
+    }
   }
 }
 
-// typescript/storage-memory.ts
+// storage-memory.ts
 class MemoryStorage {
   collections = new Map;
   ready = false;
@@ -977,8 +1484,8 @@ class MemoryStorage {
   }
 }
 
-// typescript/index.ts
-var GLOBAL_SINGLETONS = Symbol.for("@elizaos/plugin-inmemorydb/global-singletons");
+// index.ts
+var GLOBAL_SINGLETONS = Symbol.for("elizaos.plugin-inmemorydb.global-singletons");
 var globalSymbols = globalThis;
 if (!globalSymbols[GLOBAL_SINGLETONS]) {
   globalSymbols[GLOBAL_SINGLETONS] = {};
@@ -995,22 +1502,22 @@ var plugin = {
   description: "Pure in-memory, ephemeral database storage for elizaOS - no persistence",
   async init(_config, runtime) {
     logger2.info({ src: "plugin:inmemorydb" }, "Initializing in-memory database plugin");
-    const runtimeWithAdapter = runtime;
-    const hasAdapter = runtimeWithAdapter.adapter !== undefined || runtimeWithAdapter.databaseAdapter !== undefined || (runtimeWithAdapter.hasDatabaseAdapter?.() ?? false);
+    const r = runtime;
+    const hasAdapter = r.adapter !== undefined || r.databaseAdapter !== undefined || (r.hasDatabaseAdapter?.() ?? false);
     if (hasAdapter) {
       logger2.debug({ src: "plugin:inmemorydb" }, "Database adapter already exists, skipping initialization");
       return;
     }
     const adapter = createDatabaseAdapter(runtime.agentId);
-    await adapter.init();
-    runtime.registerDatabaseAdapter(adapter);
+    await adapter.initialize();
+    r.registerDatabaseAdapter?.(adapter);
     logger2.success({ src: "plugin:inmemorydb" }, "In-memory database adapter registered successfully");
   }
 };
-var typescript_default = plugin;
+var plugin_inmemorydb_default = plugin;
 export {
   plugin,
-  typescript_default as default,
+  plugin_inmemorydb_default as default,
   createDatabaseAdapter,
   MemoryStorage,
   InMemoryDatabaseAdapter,
@@ -1018,5 +1525,5 @@ export {
   COLLECTIONS
 };
 
-//# debugId=A96220E613784BE464756E2164756E21
+//# debugId=417ABAD5882812F964756E2164756E21
 //# sourceMappingURL=index.js.map