@elizaos/plugin-inmemorydb 2.0.3-beta.6 → 2.0.3-beta.7

package/dist/node/index.js

@@ -0,0 +1,1536 @@
+// index.ts
+import {
+  logger as logger2
+} from "@elizaos/core";
+
+// adapter.ts
+import { randomUUID } from "node:crypto";
+import {
+  DatabaseAdapter,
+  logger
+} from "@elizaos/core";
+
+// hnsw.ts
+function cosineDistance(a, b) {
+  if (a.length !== b.length) {
+    throw new Error(`Vector dimension mismatch: ${a.length} vs ${b.length}`);
+  }
+  let dotProduct = 0;
+  let normA = 0;
+  let normB = 0;
+  for (let i = 0;i < a.length; 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)
+    return 1;
+  return 1 - dotProduct / magnitude;
+}
+
+class EphemeralHNSW {
+  nodes = new Map;
+  entryPoint = null;
+  maxLevel = 0;
+  dimension = 0;
+  config;
+  constructor() {
+    this.config = {
+      M: 16,
+      efConstruction: 200,
+      efSearch: 50,
+      mL: 1 / Math.log(16)
+    };
+  }
+  async init(dimension) {
+    this.dimension = dimension;
+  }
+  getRandomLevel() {
+    let level = 0;
+    while (Math.random() < Math.exp(-level * this.config.mL) && level < 16) {
+      level++;
+    }
+    return level;
+  }
+  async add(id, vector) {
+    if (vector.length !== this.dimension) {
+      throw new Error(`Vector dimension mismatch: expected ${this.dimension}, got ${vector.length}`);
+    }
+    const existing = this.nodes.get(id);
+    if (existing) {
+      existing.vector = vector;
+      return;
+    }
+    const level = this.getRandomLevel();
+    const newNode = {
+      id,
+      vector,
+      level,
+      neighbors: new Map
+    };
+    for (let l = 0;l <= level; l++) {
+      newNode.neighbors.set(l, new Set);
+    }
+    if (this.entryPoint === null) {
+      this.entryPoint = id;
+      this.maxLevel = level;
+      this.nodes.set(id, newNode);
+      return;
+    }
+    let currentNode = this.entryPoint;
+    for (let l = this.maxLevel;l > level; l--) {
+      currentNode = this.searchLayer(vector, currentNode, 1, l)[0]?.id ?? currentNode;
+    }
+    for (let l = Math.min(level, this.maxLevel);l >= 0; l--) {
+      const neighbors = this.searchLayer(vector, currentNode, this.config.efConstruction, l);
+      const M = this.config.M;
+      const selectedNeighbors = neighbors.slice(0, M);
+      for (const neighbor of selectedNeighbors) {
+        const neighborSet = newNode.neighbors.get(l);
+        if (neighborSet) {
+          neighborSet.add(neighbor.id);
+        }
+        const neighborNode = this.nodes.get(neighbor.id);
+        if (neighborNode) {
+          let neighborSet2 = neighborNode.neighbors.get(l);
+          if (!neighborSet2) {
+            neighborSet2 = new Set;
+            neighborNode.neighbors.set(l, neighborSet2);
+          }
+          neighborSet2.add(id);
+          if (neighborSet2.size > M) {
+            const toKeep = this.selectBestNeighbors(neighborNode.vector, neighborSet2, M);
+            neighborNode.neighbors.set(l, new Set(toKeep.map((n) => n.id)));
+          }
+        }
+      }
+      if (neighbors.length > 0) {
+        const closestNeighbor = neighbors[0];
+        if (closestNeighbor) {
+          currentNode = closestNeighbor.id;
+        }
+      }
+    }
+    this.nodes.set(id, newNode);
+    if (level > this.maxLevel) {
+      this.maxLevel = level;
+      this.entryPoint = id;
+    }
+  }
+  searchLayer(query, entryId, ef, level) {
+    const visited = new Set([entryId]);
+    const entryNode = this.nodes.get(entryId);
+    if (!entryNode)
+      return [];
+    const entryDist = cosineDistance(query, entryNode.vector);
+    const candidates = [
+      { id: entryId, distance: entryDist }
+    ];
+    const results = [{ id: entryId, distance: entryDist }];
+    while (candidates.length > 0) {
+      candidates.sort((a, b) => a.distance - b.distance);
+      const current = candidates.shift();
+      if (!current)
+        break;
+      results.sort((a, b) => b.distance - a.distance);
+      const furthestResult = results[0];
+      if (!furthestResult)
+        break;
+      if (current.distance > furthestResult.distance) {
+        break;
+      }
+      const currentNode = this.nodes.get(current.id);
+      if (!currentNode)
+        continue;
+      const neighbors = currentNode.neighbors.get(level);
+      if (!neighbors)
+        continue;
+      for (const neighborId of neighbors) {
+        if (visited.has(neighborId))
+          continue;
+        visited.add(neighborId);
+        const neighborNode = this.nodes.get(neighborId);
+        if (!neighborNode)
+          continue;
+        const dist = cosineDistance(query, neighborNode.vector);
+        if (results.length < ef || dist < furthestResult.distance) {
+          candidates.push({ id: neighborId, distance: dist });
+          results.push({ id: neighborId, distance: dist });
+          if (results.length > ef) {
+            results.sort((a, b) => b.distance - a.distance);
+            results.pop();
+          }
+        }
+      }
+    }
+    results.sort((a, b) => a.distance - b.distance);
+    return results;
+  }
+  selectBestNeighbors(nodeVector, neighborIds, M) {
+    const neighbors = [];
+    for (const id of neighborIds) {
+      const node = this.nodes.get(id);
+      if (node) {
+        neighbors.push({
+          id,
+          distance: cosineDistance(nodeVector, node.vector)
+        });
+      }
+    }
+    neighbors.sort((a, b) => a.distance - b.distance);
+    return neighbors.slice(0, M);
+  }
+  async remove(id) {
+    const node = this.nodes.get(id);
+    if (!node)
+      return;
+    for (const [level, neighbors] of node.neighbors) {
+      for (const neighborId of neighbors) {
+        const neighborNode = this.nodes.get(neighborId);
+        if (neighborNode) {
+          neighborNode.neighbors.get(level)?.delete(id);
+        }
+      }
+    }
+    this.nodes.delete(id);
+    if (this.entryPoint === id) {
+      if (this.nodes.size === 0) {
+        this.entryPoint = null;
+        this.maxLevel = 0;
+      } else {
+        let maxLevel = 0;
+        let newEntry = null;
+        for (const [nodeId, n] of this.nodes) {
+          if (n.level >= maxLevel) {
+            maxLevel = n.level;
+            newEntry = nodeId;
+          }
+        }
+        this.entryPoint = newEntry;
+        this.maxLevel = maxLevel;
+      }
+    }
+  }
+  async search(query, k, threshold = 0.5) {
+    if (this.entryPoint === null || this.nodes.size === 0) {
+      return [];
+    }
+    if (query.length !== this.dimension) {
+      throw new Error(`Query dimension mismatch: expected ${this.dimension}, got ${query.length}`);
+    }
+    let currentNode = this.entryPoint;
+    for (let l = this.maxLevel;l > 0; l--) {
+      const closest = this.searchLayer(query, currentNode, 1, l);
+      const closestNode = closest[0];
+      if (closestNode) {
+        currentNode = closestNode.id;
+      }
+    }
+    const results = this.searchLayer(query, currentNode, Math.max(k, this.config.efSearch), 0);
+    return results.slice(0, k).filter((r) => 1 - r.distance >= threshold).map((r) => ({
+      id: r.id,
+      distance: r.distance,
+      similarity: 1 - r.distance
+    }));
+  }
+  async clear() {
+    this.nodes.clear();
+    this.entryPoint = null;
+    this.maxLevel = 0;
+  }
+  size() {
+    return this.nodes.size;
+  }
+}
+
+// types.ts
+var COLLECTIONS = {
+  AGENTS: "agents",
+  ENTITIES: "entities",
+  MEMORIES: "memories",
+  ROOMS: "rooms",
+  WORLDS: "worlds",
+  COMPONENTS: "components",
+  RELATIONSHIPS: "relationships",
+  PARTICIPANTS: "participants",
+  TASKS: "tasks",
+  CACHE: "cache",
+  LOGS: "logs",
+  EMBEDDINGS: "embeddings",
+  PAIRING_REQUESTS: "pairing_requests",
+  PAIRING_ALLOWLIST: "pairing_allowlist"
+};
+
+// adapter.ts
+function toMemory(stored) {
+  return {
+    id: stored.id,
+    entityId: stored.entityId,
+    agentId: stored.agentId,
+    createdAt: stored.createdAt,
+    content: stored.content,
+    embedding: stored.embedding,
+    roomId: stored.roomId,
+    worldId: stored.worldId,
+    unique: stored.unique,
+    similarity: stored.similarity,
+    metadata: stored.metadata
+  };
+}
+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 {
+  storage;
+  vectorIndex;
+  embeddingDimension = 384;
+  ready = false;
+  agentId;
+  constructor(storage, agentId) {
+    super();
+    this.storage = storage;
+    this.agentId = agentId;
+    this.db = storage;
+    this.vectorIndex = new EphemeralHNSW;
+  }
+  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");
+  }
+  async isReady() {
+    return this.ready && await this.storage.isReady();
+  }
+  async close() {
+    await this.vectorIndex.clear();
+    await this.storage.close();
+    this.ready = false;
+    logger.info({ src: "plugin:inmemorydb" }, "In-memory database closed");
+  }
+  async getConnection() {
+    return this.storage;
+  }
+  async transaction(callback, _options) {
+    return callback(this);
+  }
+  async ensureEmbeddingDimension(dimension) {
+    if (this.embeddingDimension !== dimension) {
+      this.embeddingDimension = dimension;
+      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) {
+      const entity = await this.storage.get(COLLECTIONS.ENTITIES, id);
+      if (entity)
+        entities.push(entity);
+    }
+    return entities;
+  }
+  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;
+        }
+      }
+      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 createComponents(components) {
+    const ids = [];
+    for (const component of components) {
+      const id = component.id;
+      await this.storage.set(COLLECTIONS.COMPONENTS, id, { ...component, id });
+      ids.push(id);
+    }
+    return ids;
+  }
+  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 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 deleteComponents(componentIds) {
+    for (const id of componentIds) {
+      await this.storage.delete(COLLECTIONS.COMPONENTS, id);
+    }
+  }
+  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 === component.worldId && c.sourceEntityId === component.sourceEntityId);
+      const existing = naturalKey[0];
+      if (existing) {
+        await this.storage.set(COLLECTIONS.COMPONENTS, existing.id, {
+          ...existing,
+          ...component,
+          id: existing.id
+        });
+      } else {
+        const id = component.id;
+        await this.storage.set(COLLECTIONS.COMPONENTS, id, {
+          ...component,
+          id
+        });
+      }
+    }
+  }
+  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 === (key.worldId ?? null) && c.sourceEntityId === (key.sourceEntityId ?? null));
+      result.push(matches[0] ?? null);
+    }
+    return result;
+  }
+  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) => {
+      if (params.entityId && m.entityId !== params.entityId)
+        return false;
+      if (params.agentId && m.agentId !== params.agentId)
+        return false;
+      if (params.roomId && m.roomId !== params.roomId)
+        return false;
+      if (params.worldId && m.worldId !== params.worldId)
+        return false;
+      if (params.tableName && m.metadata?.type !== params.tableName)
+        return false;
+      if (params.start && m.createdAt && m.createdAt < params.start)
+        return false;
+      if (params.end && m.createdAt && m.createdAt > params.end)
+        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));
+    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) {
+    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));
+    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 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 && !!m.embedding);
+    const results = [];
+    for (const memory of memories) {
+      if (!memory.embedding)
+        continue;
+      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.sort((a, b) => a.levenshtein_score - b.levenshtein_score);
+    return results.slice(0, params.query_match_count);
+  }
+  async searchMemories(params) {
+    const threshold = params.match_threshold ?? 0.5;
+    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);
+      if (!memory)
+        continue;
+      if (params.tableName && memory.metadata?.type !== params.tableName)
+        continue;
+      if (params.roomId && memory.roomId !== params.roomId)
+        continue;
+      if (params.worldId && memory.worldId !== params.worldId)
+        continue;
+      if (params.entityId && memory.entityId !== params.entityId)
+        continue;
+      if (params.unique && !memory.unique)
+        continue;
+      memories.push({ ...toMemory(memory), similarity: result.similarity });
+    }
+    return memories.slice(0, limit);
+  }
+  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);
+      }
+      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);
+      }
+    }
+  }
+  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 deleteMemories(memoryIds) {
+    for (const id of memoryIds) {
+      await this.storage.delete(COLLECTIONS.MEMORIES, id);
+      await this.vectorIndex.remove(id);
+    }
+  }
+  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 (params.unique && !m.unique)
+        return false;
+      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 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));
+    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);
+    }
+  }
+  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 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 deleteLogs(logIds) {
+    for (const id of logIds) {
+      await this.storage.delete(COLLECTIONS.LOGS, id);
+    }
+  }
+  async getAllWorlds() {
+    return this.storage.getAll(COLLECTIONS.WORLDS);
+  }
+  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;
+      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;
+      const existing = await this.storage.get(COLLECTIONS.WORLDS, id);
+      await this.storage.set(COLLECTIONS.WORLDS, id, {
+        ...existing ?? {},
+        ...world,
+        id
+      });
+    }
+  }
+  async getRoomsByIds(roomIds) {
+    const rooms = [];
+    for (const id of roomIds) {
+      const room = await this.storage.get(COLLECTIONS.ROOMS, id);
+      if (room)
+        rooms.push(room);
+    }
+    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;
+      await this.storage.set(COLLECTIONS.ROOMS, id, { ...room, id });
+      ids.push(id);
+    }
+    return ids;
+  }
+  async upsertRooms(rooms) {
+    for (const room of rooms) {
+      const id = room.id;
+      const existing = await this.storage.get(COLLECTIONS.ROOMS, id);
+      await this.storage.set(COLLECTIONS.ROOMS, id, {
+        ...existing ?? {},
+        ...room,
+        id
+      });
+    }
+  }
+  async updateRooms(rooms) {
+    for (const room of rooms) {
+      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 deleteRooms(roomIds) {
+    if (roomIds.length === 0)
+      return;
+    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 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 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 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);
+      }
+    }
+  }
+  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 });
+    }
+    return participants;
+  }
+  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 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 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 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
+        });
+      }
+    }
+  }
+  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 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) {
+        const tags = r.tags ?? [];
+        if (!params.tags.some((t) => tags.includes(t)))
+          return false;
+      }
+      return true;
+    });
+    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 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 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,
+        targetEntityId: rel.targetEntityId,
+        agentId: rel.agentId,
+        tags: rel.tags,
+        metadata: { ...existing.metadata ?? {}, ...rel.metadata ?? {} }
+      };
+      await this.storage.set(COLLECTIONS.RELATIONSHIPS, rel.id, next);
+    }
+  }
+  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 setCaches(entries) {
+    for (const { key, value } of entries) {
+      await this.storage.set(COLLECTIONS.CACHE, key, { value });
+    }
+    return true;
+  }
+  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) {
+    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) {
+        const tags = t.tags ?? [];
+        if (!params.tags.some((tag) => tags.includes(tag)))
+          return false;
+      }
+      return true;
+    });
+    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 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 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 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 deleteTasks(taskIds) {
+    for (const id of taskIds) {
+      await this.storage.delete(COLLECTIONS.TASKS, id);
+    }
+  }
+  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;
+      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 deletePairingRequests(ids) {
+    for (const id of ids) {
+      await this.storage.delete(COLLECTIONS.PAIRING_REQUESTS, id);
+    }
+  }
+  async createPairingAllowlistEntries(entries) {
+    const ids = [];
+    for (const entry of entries) {
+      const id = entry.id;
+      await this.storage.set(COLLECTIONS.PAIRING_ALLOWLIST, id, {
+        ...entry,
+        id
+      });
+      ids.push(id);
+    }
+    return ids;
+  }
+  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 deletePairingAllowlistEntries(ids) {
+    for (const id of ids) {
+      await this.storage.delete(COLLECTIONS.PAIRING_ALLOWLIST, id);
+    }
+  }
+}
+
+// storage-memory.ts
+class MemoryStorage {
+  collections = new Map;
+  ready = false;
+  async init() {
+    this.ready = true;
+  }
+  async close() {
+    this.collections.clear();
+    this.ready = false;
+  }
+  async isReady() {
+    return this.ready;
+  }
+  getCollection(collection) {
+    this.assertReady();
+    let col = this.collections.get(collection);
+    if (!col) {
+      col = new Map;
+      this.collections.set(collection, col);
+    }
+    return col;
+  }
+  assertReady() {
+    if (!this.ready) {
+      throw new Error("MemoryStorage is not initialized");
+    }
+  }
+  async get(collection, id) {
+    const col = this.getCollection(collection);
+    const item = col.get(id);
+    return item !== undefined ? item : null;
+  }
+  async getAll(collection) {
+    const col = this.getCollection(collection);
+    return Array.from(col.values());
+  }
+  async getWhere(collection, predicate) {
+    const all = await this.getAll(collection);
+    return all.filter(predicate);
+  }
+  async set(collection, id, data) {
+    const col = this.getCollection(collection);
+    col.set(id, data);
+  }
+  async delete(collection, id) {
+    const col = this.getCollection(collection);
+    return col.delete(id);
+  }
+  async deleteMany(collection, ids) {
+    const col = this.getCollection(collection);
+    for (const id of ids) {
+      col.delete(id);
+    }
+  }
+  async deleteWhere(collection, predicate) {
+    const col = this.getCollection(collection);
+    const toDelete = [];
+    for (const [id, item] of col) {
+      if (predicate(item)) {
+        toDelete.push(id);
+      }
+    }
+    for (const id of toDelete) {
+      col.delete(id);
+    }
+  }
+  async count(collection, predicate) {
+    const col = this.getCollection(collection);
+    if (!predicate) {
+      return col.size;
+    }
+    let count = 0;
+    for (const item of col.values()) {
+      if (predicate(item)) {
+        count++;
+      }
+    }
+    return count;
+  }
+  async clear() {
+    this.assertReady();
+    this.collections.clear();
+  }
+}
+
+// index.ts
+var GLOBAL_SINGLETONS = Symbol.for("elizaos.plugin-inmemorydb.global-singletons");
+var globalSymbols = globalThis;
+if (!globalSymbols[GLOBAL_SINGLETONS]) {
+  globalSymbols[GLOBAL_SINGLETONS] = {};
+}
+var globalSingletons = globalSymbols[GLOBAL_SINGLETONS];
+function createDatabaseAdapter(agentId) {
+  if (!globalSingletons.storageManager) {
+    globalSingletons.storageManager = new MemoryStorage;
+  }
+  return new InMemoryDatabaseAdapter(globalSingletons.storageManager, agentId);
+}
+var plugin = {
+  name: "@elizaos/plugin-inmemorydb",
+  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 r = runtime;
+    const hasAdapter = r.adapter !== undefined || r.databaseAdapter !== undefined || (r.hasDatabaseAdapter?.() ?? false);
+    if (hasAdapter) {
+      logger2.debug({ src: "plugin:inmemorydb" }, "Database adapter already exists; keeping current adapter");
+      return;
+    }
+    const adapter = createDatabaseAdapter(runtime.agentId);
+    await adapter.initialize();
+    r.registerDatabaseAdapter?.(adapter);
+    logger2.success({ src: "plugin:inmemorydb" }, "In-memory database adapter registered successfully");
+  }
+};
+var plugin_inmemorydb_default = plugin;
+export {
+  plugin,
+  plugin_inmemorydb_default as default,
+  createDatabaseAdapter,
+  MemoryStorage,
+  InMemoryDatabaseAdapter,
+  EphemeralHNSW,
+  COLLECTIONS
+};
+
+//# debugId=5D21BF0F093E14FA64756E2164756E21
+//# sourceMappingURL=index.js.map