@elizaos/plugin-localdb 2.0.0-alpha.4 → 2.0.0-alpha.5

package/dist/browser/index.browser.js

@@ -1,1133 +1,42 @@
-// index.browser.ts
-import {
-  logger as logger2
-} from "@elizaos/core";
-
-// adapter.ts
-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++) {
-    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 SimpleHNSW {
-  nodes = new Map;
-  entryPoint = null;
-  maxLevel = 0;
-  dimension = 0;
-  config;
-  saveCallback;
-  loadCallback;
-  constructor(saveCallback, loadCallback) {
-    this.config = {
-      M: 16,
-      efConstruction: 200,
-      efSearch: 50,
-      mL: 1 / Math.log(16)
-    };
-    this.saveCallback = saveCallback;
-    this.loadCallback = loadCallback;
-  }
-  async init(dimension) {
-    this.dimension = dimension;
-    if (this.loadCallback) {
-      const index = await this.loadCallback();
-      if (index && index.dimension === dimension) {
-        this.deserialize(index);
-      }
-    }
-  }
-  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}`);
-    }
-    if (this.nodes.has(id)) {
-      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) {
-        newNode.neighbors.get(l)?.add(neighbor.id);
-        const neighborNode = this.nodes.get(neighbor.id);
-        if (neighborNode) {
-          let neighborSet = neighborNode.neighbors.get(l);
-          if (!neighborSet) {
-            neighborSet = new Set;
-            neighborNode.neighbors.set(l, neighborSet);
-          }
-          neighborSet.add(id);
-          if (neighborSet.size > M) {
-            const toKeep = this.selectBestNeighbors(neighborNode.vector, neighborSet, M, l);
-            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, _level) {
-    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 save() {
-    if (this.saveCallback) {
-      await this.saveCallback();
-    }
-  }
-  async load() {
-    if (this.loadCallback) {
-      const index = await this.loadCallback();
-      if (index) {
-        this.deserialize(index);
-      }
-    }
-  }
-  serialize() {
-    const nodes = {};
-    for (const [id, node] of this.nodes) {
-      const neighbors = {};
-      for (const [level, set] of node.neighbors) {
-        neighbors[level] = Array.from(set);
-      }
-      nodes[id] = {
-        id: node.id,
-        vector: node.vector,
-        level: node.level,
-        neighbors
-      };
-    }
-    return {
-      dimension: this.dimension,
-      config: this.config,
-      nodes,
-      entryPoint: this.entryPoint,
-      maxLevel: this.maxLevel
-    };
-  }
-  deserialize(index) {
-    this.dimension = index.dimension;
-    this.config = index.config;
-    this.entryPoint = index.entryPoint;
-    this.maxLevel = index.maxLevel;
-    this.nodes.clear();
-    for (const [id, serialized] of Object.entries(index.nodes)) {
-      const neighbors = new Map;
-      for (const [level, ids] of Object.entries(serialized.neighbors)) {
-        neighbors.set(Number(level), new Set(ids));
-      }
-      this.nodes.set(id, {
-        id: serialized.id,
-        vector: serialized.vector,
-        level: serialized.level,
-        neighbors
-      });
-    }
-  }
-  getIndex() {
-    return this.serialize();
-  }
-  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 toMemories(stored) {
-  return stored.map(toMemory);
-}
-
-class LocalDatabaseAdapter extends DatabaseAdapter {
-  storage;
-  vectorIndex;
-  embeddingDimension = 384;
-  ready = false;
-  agentId;
-  constructor(storage, agentId) {
-    super();
-    this.storage = storage;
-    this.agentId = agentId;
-    this.vectorIndex = new SimpleHNSW(async () => {
-      const index = this.vectorIndex.getIndex();
-      await this.storage.saveRaw("vectors/hnsw_index.json", JSON.stringify(index));
-    }, async () => {
-      const data = await this.storage.loadRaw("vectors/hnsw_index.json");
-      if (data) {
-        try {
-          return JSON.parse(data);
-        } catch {
-          return null;
-        }
-      }
-      return null;
-    });
-  }
-  async initialize() {
-    await this.init();
-  }
-  async init() {
-    await this.storage.init();
-    await this.vectorIndex.init(this.embeddingDimension);
-    this.ready = true;
-    logger.info({ src: "plugin:localdb" }, "Local database initialized");
-  }
-  async runPluginMigrations(_plugins, _options) {
-    logger.debug({ src: "plugin:localdb" }, "Plugin migrations not needed for JSON storage");
-  }
-  async isReady() {
-    return this.ready && await this.storage.isReady();
-  }
-  async close() {
-    await this.vectorIndex.save();
-    await this.storage.close();
-    this.ready = false;
-    logger.info({ src: "plugin:localdb" }, "Local 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);
-      await this.vectorIndex.save();
-    }
-    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);
-      await this.vectorIndex.save();
-    }
-    return true;
-  }
-  async deleteMemory(memoryId) {
-    await this.storage.delete(COLLECTIONS.MEMORIES, memoryId);
-    await this.vectorIndex.remove(memoryId);
-    await this.vectorIndex.save();
-  }
-  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);
-  }
-  async getPairingRequests(channel, agentId) {
-    return this.storage.getWhere(COLLECTIONS.PAIRING_REQUESTS, (r) => r.channel === channel && r.agentId === agentId);
-  }
-  async createPairingRequest(request) {
-    const id = request.id ?? crypto.randomUUID();
-    await this.storage.set(COLLECTIONS.PAIRING_REQUESTS, id, { ...request, id });
-    return id;
-  }
-  async updatePairingRequest(request) {
-    const existing = await this.storage.get(COLLECTIONS.PAIRING_REQUESTS, request.id);
-    if (existing) {
-      await this.storage.set(COLLECTIONS.PAIRING_REQUESTS, request.id, {
-        ...existing,
-        ...request
-      });
-    }
-  }
-  async deletePairingRequest(id) {
-    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 createPairingAllowlistEntry(entry) {
-    const id = entry.id ?? crypto.randomUUID();
-    await this.storage.set(COLLECTIONS.PAIRING_ALLOWLIST, id, { ...entry, id });
-    return id;
-  }
-  async deletePairingAllowlistEntry(id) {
-    await this.storage.delete(COLLECTIONS.PAIRING_ALLOWLIST, id);
-  }
-}
-
-// storage-browser.ts
-class BrowserStorage {
-  prefix;
-  ready = false;
-  constructor(prefix = "elizaos") {
-    this.prefix = prefix;
-  }
-  async init() {
-    this.ready = typeof localStorage !== "undefined";
-    if (!this.ready) {
-      throw new Error("localStorage is not available in this environment");
-    }
-  }
-  async close() {
-    this.ready = false;
-  }
-  async isReady() {
-    return this.ready;
-  }
-  getKey(collection, id) {
-    return `${this.prefix}:${collection}:${id}`;
-  }
-  getCollectionPrefix(collection) {
-    return `${this.prefix}:${collection}:`;
-  }
-  getAllKeysForCollection(collection) {
-    const prefix = this.getCollectionPrefix(collection);
-    const keys = [];
-    for (let i = 0;i < localStorage.length; i++) {
-      const key = localStorage.key(i);
-      if (key?.startsWith(prefix)) {
-        keys.push(key);
-      }
-    }
-    return keys;
-  }
-  async get(collection, id) {
-    try {
-      const key = this.getKey(collection, id);
-      const data = localStorage.getItem(key);
-      if (!data)
-        return null;
-      return JSON.parse(data);
-    } catch {
-      return null;
-    }
-  }
-  async getAll(collection) {
-    const keys = this.getAllKeysForCollection(collection);
-    const items = [];
-    for (const key of keys) {
-      try {
-        const data = localStorage.getItem(key);
-        if (data) {
-          items.push(JSON.parse(data));
-        }
-      } catch {}
-    }
-    return items;
-  }
-  async getWhere(collection, predicate) {
-    const all = await this.getAll(collection);
-    return all.filter(predicate);
-  }
-  async set(collection, id, data) {
-    const key = this.getKey(collection, id);
-    localStorage.setItem(key, JSON.stringify(data));
-  }
-  async delete(collection, id) {
-    const key = this.getKey(collection, id);
-    if (localStorage.getItem(key) === null) {
-      return false;
-    }
-    localStorage.removeItem(key);
-    return true;
-  }
-  async deleteMany(collection, ids) {
-    for (const id of ids) {
-      await this.delete(collection, id);
-    }
-  }
-  async deleteWhere(collection, predicate) {
-    const keys = this.getAllKeysForCollection(collection);
-    for (const key of keys) {
-      try {
-        const data = localStorage.getItem(key);
-        if (data) {
-          const item = JSON.parse(data);
-          if (predicate(item)) {
-            localStorage.removeItem(key);
-          }
-        }
-      } catch {}
-    }
-  }
-  async count(collection, predicate) {
-    if (!predicate) {
-      return this.getAllKeysForCollection(collection).length;
-    }
-    const items = await this.getAll(collection);
-    return items.filter(predicate).length;
-  }
-  async saveRaw(filename, data) {
-    const key = `${this.prefix}:_raw:${filename}`;
-    localStorage.setItem(key, data);
-  }
-  async loadRaw(filename) {
-    const key = `${this.prefix}:_raw:${filename}`;
-    return localStorage.getItem(key);
-  }
-}
-
-// index.browser.ts
-var GLOBAL_SINGLETONS = Symbol.for("@elizaos/plugin-localdb/global-singletons");
-var globalSymbols = globalThis;
+import { logger, } from "@elizaos/core";
+import { LocalDatabaseAdapter } from "./adapter";
+import { BrowserStorage } from "./storage-browser";
+const GLOBAL_SINGLETONS = Symbol.for("@elizaos/plugin-localdb/global-singletons");
+const globalSymbols = globalThis;
 if (!globalSymbols[GLOBAL_SINGLETONS]) {
-  globalSymbols[GLOBAL_SINGLETONS] = {};
-}
-var globalSingletons = globalSymbols[GLOBAL_SINGLETONS];
-function createDatabaseAdapter(config, agentId) {
-  const prefix = config.prefix ?? "elizaos";
-  if (!globalSingletons.storageManager) {
-    globalSingletons.storageManager = new BrowserStorage(prefix);
-  }
-  return new LocalDatabaseAdapter(globalSingletons.storageManager, agentId);
-}
-var plugin = {
-  name: "@elizaos/plugin-localdb",
-  description: "Simple JSON-based local database storage for elizaOS (browser)",
-  async init(_config, runtime) {
-    logger2.info({ src: "plugin:localdb" }, "Initializing local database plugin (browser)");
-    const runtimeWithAdapter = runtime;
-    const hasAdapter = runtimeWithAdapter.adapter !== undefined || runtimeWithAdapter.databaseAdapter !== undefined || (runtimeWithAdapter.hasDatabaseAdapter?.() ?? false);
-    if (hasAdapter) {
-      logger2.debug({ src: "plugin:localdb" }, "Database adapter already exists, skipping initialization");
-      return;
-    }
-    const prefix = runtime.getSetting("LOCALDB_PREFIX");
-    const adapter = createDatabaseAdapter({ prefix }, runtime.agentId);
-    await adapter.init();
-    runtime.registerDatabaseAdapter(adapter);
-    logger2.success({ src: "plugin:localdb" }, "Local database adapter registered successfully");
-  }
-};
-var index_browser_default = plugin;
-export {
-  plugin,
-  index_browser_default as default,
-  createDatabaseAdapter,
-  SimpleHNSW,
-  LocalDatabaseAdapter,
-  COLLECTIONS,
-  BrowserStorage
+    globalSymbols[GLOBAL_SINGLETONS] = {};
+}
+const globalSingletons = globalSymbols[GLOBAL_SINGLETONS];
+export function createDatabaseAdapter(config, agentId) {
+    const prefix = config.prefix ?? "elizaos";
+    if (!globalSingletons.storageManager) {
+        globalSingletons.storageManager = new BrowserStorage(prefix);
+    }
+    return new LocalDatabaseAdapter(globalSingletons.storageManager, agentId);
+}
+export const plugin = {
+    name: "@elizaos/plugin-localdb",
+    description: "Simple JSON-based local database storage for elizaOS (browser)",
+    async init(_config, runtime) {
+        logger.info({ src: "plugin:localdb" }, "Initializing local database plugin (browser)");
+        const runtimeWithAdapter = runtime;
+        const hasAdapter = runtimeWithAdapter.adapter !== undefined ||
+            runtimeWithAdapter.databaseAdapter !== undefined ||
+            (runtimeWithAdapter.hasDatabaseAdapter?.() ?? false);
+        if (hasAdapter) {
+            logger.debug({ src: "plugin:localdb" }, "Database adapter already exists, skipping initialization");
+            return;
+        }
+        const prefix = runtime.getSetting("LOCALDB_PREFIX");
+        const adapter = createDatabaseAdapter({ prefix }, runtime.agentId);
+        await adapter.init();
+        runtime.registerDatabaseAdapter(adapter);
+        logger.success({ src: "plugin:localdb" }, "Local database adapter registered successfully");
+    },
 };
-
-//# debugId=8C04012B3A2B8CE164756E2164756E21
-//# sourceMappingURL=index.browser.js.map
+export { LocalDatabaseAdapter } from "./adapter";
+export { SimpleHNSW } from "./hnsw";
+export { BrowserStorage } from "./storage-browser";
+export * from "./types";
+export default plugin;
+//# sourceMappingURL=index.browser.js.map