@elizaos/plugin-inmemorydb 2.0.0-alpha.1

package/dist/node/index.js

@@ -0,0 +1,989 @@
+// typescript/index.ts
+import {
+  logger as logger2
+} from "@elizaos/core";
+
+// typescript/adapter.ts
+import {
+  DatabaseAdapter,
+  logger
+} from "@elizaos/core";
+
+// typescript/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++) {
+    dotProduct += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+  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) {
+        currentNode = neighbors[0].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 (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);
+      if (closest.length > 0) {
+        currentNode = closest[0].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;
+  }
+}
+
+// typescript/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"
+};
+
+// typescript/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 toMemories(stored) {
+  return stored.map(toMemory);
+}
+
+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() {
+    await this.init();
+  }
+  async init() {
+    await this.storage.init();
+    await this.vectorIndex.init(this.embeddingDimension);
+    this.ready = true;
+    logger.info({ src: "plugin:inmemorydb" }, "In-memory database initialized");
+  }
+  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 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 ensureEmbeddingDimension(dimension) {
+    if (this.embeddingDimension !== dimension) {
+      this.embeddingDimension = dimension;
+      await this.vectorIndex.init(dimension);
+    }
+  }
+  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.length > 0 ? entities : null;
+  }
+  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);
+          entity.components = components;
+        }
+        entities.push(entity);
+      }
+    }
+    return entities;
+  }
+  async createEntities(entities) {
+    for (const entity of entities) {
+      if (!entity.id)
+        continue;
+      await this.storage.set(COLLECTIONS.ENTITIES, entity.id, entity);
+    }
+    return true;
+  }
+  async updateEntity(entity) {
+    if (!entity.id)
+      return;
+    await this.storage.set(COLLECTIONS.ENTITIES, entity.id, entity);
+  }
+  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 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 createComponent(component) {
+    if (!component.id)
+      return false;
+    await this.storage.set(COLLECTIONS.COMPONENTS, component.id, component);
+    return true;
+  }
+  async updateComponent(component) {
+    if (!component.id)
+      return;
+    await this.storage.set(COLLECTIONS.COMPONENTS, component.id, component);
+  }
+  async deleteComponent(componentId) {
+    await this.storage.delete(COLLECTIONS.COMPONENTS, componentId);
+  }
+  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;
+      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);
+  }
+  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));
+    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);
+  }
+  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));
+      }
+    }
+    return memories;
+  }
+  async getCachedEmbeddings(params) {
+    const memories = await this.storage.getWhere(COLLECTIONS.MEMORIES, (m) => m.metadata?.type === params.query_table_name);
+    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);
+      if (score <= params.query_threshold) {
+        results.push({
+          embedding: memory.embedding,
+          levenshtein_score: 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 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, count);
+  }
+  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
+      }
+    };
+    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 ?? {}
+      }
+    };
+    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 deleteManyMemories(memoryIds) {
+    for (const id of memoryIds) {
+      await this.deleteMemory(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)
+        return false;
+      if (unique && !memory.unique)
+        return false;
+      if (tableName && memory.metadata?.type !== tableName)
+        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));
+    memories.sort((a, b) => (b.createdAt ?? 0) - (a.createdAt ?? 0));
+    if (params.count) {
+      return toMemories(memories.slice(0, params.count));
+    }
+    return toMemories(memories);
+  }
+  async createWorld(world) {
+    const id = world.id ?? crypto.randomUUID();
+    await this.storage.set(COLLECTIONS.WORLDS, id, { ...world, id });
+    return id;
+  }
+  async getWorld(id) {
+    return this.storage.get(COLLECTIONS.WORLDS, id);
+  }
+  async removeWorld(id) {
+    await this.storage.delete(COLLECTIONS.WORLDS, 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 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.length > 0 ? rooms : null;
+  }
+  async createRooms(rooms) {
+    const ids = [];
+    for (const room of rooms) {
+      const id = room.id ?? crypto.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 deleteRoomsByWorldId(worldId) {
+    const rooms = await this.getRoomsByWorld(worldId);
+    for (const room of rooms) {
+      if (room.id) {
+        await this.deleteRoom(room.id);
+      }
+    }
+  }
+  async updateRoom(room) {
+    if (!room.id)
+      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);
+  }
+  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 getRoomsByWorld(worldId) {
+    return this.storage.getWhere(COLLECTIONS.ROOMS, (r) => r.worldId === worldId);
+  }
+  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);
+      }
+    }
+    return true;
+  }
+  async getParticipantsForEntity(entityId) {
+    const stored = await this.storage.getWhere(COLLECTIONS.PARTICIPANTS, (p) => p.entityId === 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 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 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);
+      }
+    }
+    return true;
+  }
+  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) {
+        await this.storage.set(COLLECTIONS.PARTICIPANTS, p.id, {
+          ...p,
+          userState: state
+        });
+      }
+    }
+  }
+  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 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;
+      if (params.tags && params.tags.length > 0) {
+        return params.tags.some((tag) => r.tags?.includes(tag));
+      }
+      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
+    }));
+  }
+  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 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;
+    }
+    return cached.value;
+  }
+  async setCache(key, value) {
+    await this.storage.set(COLLECTIONS.CACHE, key, { value });
+    return true;
+  }
+  async deleteCache(key) {
+    return this.storage.delete(COLLECTIONS.CACHE, key);
+  }
+  async createTask(task) {
+    const id = task.id ?? crypto.randomUUID();
+    await this.storage.set(COLLECTIONS.TASKS, id, { ...task, id });
+    return id;
+  }
+  async getTasks(params) {
+    return this.storage.getWhere(COLLECTIONS.TASKS, (t) => {
+      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)))
+          return false;
+      }
+      return true;
+    });
+  }
+  async getTask(id) {
+    return this.storage.get(COLLECTIONS.TASKS, id);
+  }
+  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 deleteTask(id) {
+    await this.storage.delete(COLLECTIONS.TASKS, id);
+  }
+}
+
+// typescript/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) {
+    let col = this.collections.get(collection);
+    if (!col) {
+      col = new Map;
+      this.collections.set(collection, col);
+    }
+    return col;
+  }
+  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.collections.clear();
+  }
+}
+
+// typescript/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 runtimeWithAdapter = runtime;
+    const hasAdapter = runtimeWithAdapter.adapter !== undefined || runtimeWithAdapter.databaseAdapter !== undefined || (runtimeWithAdapter.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);
+    logger2.success({ src: "plugin:inmemorydb" }, "In-memory database adapter registered successfully");
+  }
+};
+var typescript_default = plugin;
+export {
+  plugin,
+  typescript_default as default,
+  createDatabaseAdapter,
+  MemoryStorage,
+  InMemoryDatabaseAdapter,
+  EphemeralHNSW,
+  COLLECTIONS
+};
+
+//# debugId=5063BCFF84A0E87D64756E2164756E21
+//# sourceMappingURL=index.js.map