@elizaos/ui 2.0.0-alpha.25 → 2.0.0-alpha.334

package/packages/typescript/src/database/inMemoryAdapter.js

@@ -0,0 +1,1171 @@
+import { DatabaseAdapter } from "../database";
+import { DEFAULT_UUID } from "../types/primitives";
+function asUuid(id) {
+    return id;
+}
+function roomTableKey(tableName, roomId) {
+    return `${tableName}:${String(roomId)}`;
+}
+function componentNaturalKey(params) {
+    return [
+        String(params.entityId),
+        params.type,
+        String(params.worldId ?? ""),
+        String(params.sourceEntityId ?? ""),
+    ].join("::");
+}
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function dataContainsFilter(value, filter) {
+    if (!filter)
+        return true;
+    if (!isPlainObject(value))
+        return false;
+    for (const [key, expected] of Object.entries(filter)) {
+        const actual = value[key];
+        if (isPlainObject(expected)) {
+            if (!dataContainsFilter(actual, expected)) {
+                return false;
+            }
+            continue;
+        }
+        if (Array.isArray(expected)) {
+            if (!Array.isArray(actual))
+                return false;
+            for (const expectedItem of expected) {
+                const found = actual.some((actualItem) => {
+                    if (isPlainObject(expectedItem)) {
+                        return dataContainsFilter(actualItem, expectedItem);
+                    }
+                    return actualItem === expectedItem;
+                });
+                if (!found)
+                    return false;
+            }
+            continue;
+        }
+        if (actual !== expected) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * In-memory database adapter.
+ *
+ * Intended for:
+ * - Unit / integration tests (fast, no external dependencies)
+ * - Benchmarks (measure agent logic without DB latency)
+ * - Serverless / ephemeral runs (no persistence needed)
+ *
+ * Implements the full batch-first `IDatabaseAdapter` surface using plain
+ * Maps and arrays. No single-item CRUD methods exist here -- those are
+ * convenience wrappers on AgentRuntime that delegate to these batch methods.
+ *
+ * WHY Maps and not a single big array:
+ * - `memoriesById` gives O(1) ID lookups (batch getMemoriesByIds)
+ * - `memoriesByRoom` gives O(1) room-scoped queries (getMemories, countMemories)
+ * - This mirrors how SQL adapters use indexed columns, keeping the
+ *   in-memory adapter's performance characteristics honest.
+ *
+ * Persistence is process-local. Data is lost on restart.
+ */
+export class InMemoryDatabaseAdapter extends DatabaseAdapter {
+    db = {};
+    ready = false;
+    agents = new Map();
+    entities = new Map();
+    components = new Map();
+    componentIdsByEntity = new Map();
+    componentIdsByNaturalKey = new Map();
+    rooms = new Map();
+    worlds = new Map();
+    tasks = new Map();
+    logs = [];
+    memoriesById = new Map();
+    memoriesByRoom = new Map();
+    cache = new Map();
+    participantsByRoom = new Map();
+    roomsByParticipant = new Map();
+    participantUserState = new Map();
+    // Pairing storage
+    pairingRequests = new Map();
+    pairingAllowlist = new Map();
+    cloneComponent(component) {
+        return {
+            ...component,
+            data: component.data
+                ? { ...component.data }
+                : component.data,
+        };
+    }
+    attachComponents(entity, components) {
+        const attachedComponents = components ?? this.getStoredComponentsForEntity(entity.id);
+        if (!attachedComponents.length) {
+            return { ...entity };
+        }
+        return {
+            ...entity,
+            components: attachedComponents.map((component) => this.cloneComponent(component)),
+        };
+    }
+    getStoredComponentsForEntity(entityId, options) {
+        if (!entityId)
+            return [];
+        const componentIds = this.componentIdsByEntity.get(String(entityId));
+        if (!componentIds)
+            return [];
+        const components = [];
+        for (const componentId of componentIds) {
+            const component = this.components.get(componentId);
+            if (!component)
+                continue;
+            if (options?.worldId !== undefined &&
+                component.worldId !== options.worldId) {
+                continue;
+            }
+            if (options?.sourceEntityId !== undefined &&
+                component.sourceEntityId !== options.sourceEntityId) {
+                continue;
+            }
+            components.push(component);
+        }
+        return components;
+    }
+    indexComponent(component) {
+        const componentId = String(component.id);
+        this.components.set(componentId, this.cloneComponent(component));
+        const entityKey = String(component.entityId);
+        const entityComponents = this.componentIdsByEntity.get(entityKey) ?? new Set();
+        entityComponents.add(componentId);
+        this.componentIdsByEntity.set(entityKey, entityComponents);
+        this.componentIdsByNaturalKey.set(componentNaturalKey(component), componentId);
+    }
+    removeComponentIndexes(component) {
+        if (!component)
+            return;
+        const componentId = String(component.id);
+        const entityKey = String(component.entityId);
+        const entityComponents = this.componentIdsByEntity.get(entityKey);
+        if (entityComponents) {
+            entityComponents.delete(componentId);
+            if (entityComponents.size === 0) {
+                this.componentIdsByEntity.delete(entityKey);
+            }
+        }
+        this.componentIdsByNaturalKey.delete(componentNaturalKey(component));
+    }
+    async initialize(_config) {
+        this.ready = true;
+    }
+    async init() {
+        this.ready = true;
+    }
+    async runPluginMigrations() {
+        // no-op
+    }
+    async runMigrations() {
+        // no-op
+    }
+    async isReady() {
+        return this.ready;
+    }
+    async close() {
+        this.ready = false;
+    }
+    async getConnection() {
+        return this.db;
+    }
+    // Batch agent methods
+    async getAgentsByIds(agentIds) {
+        const agents = [];
+        for (const id of agentIds) {
+            const agent = this.agents.get(String(id));
+            if (agent?.id) {
+                agents.push(agent);
+            }
+        }
+        return agents;
+    }
+    async createAgents(agents) {
+        const ids = [];
+        for (const agent of agents) {
+            if (agent.id) {
+                this.agents.set(String(agent.id), agent);
+                ids.push(agent.id);
+            }
+        }
+        return ids;
+    }
+    async upsertAgents(agents) {
+        // WHY simple set: Map.set() overwrites if key exists, inserts if not.
+        // This is the InMemory equivalent of ON CONFLICT DO UPDATE.
+        for (const agent of agents) {
+            if (agent.id) {
+                this.agents.set(String(agent.id), agent);
+            }
+        }
+    }
+    async updateAgents(updates) {
+        for (const { agentId, agent } of updates) {
+            const existing = this.agents.get(String(agentId)) ?? {};
+            this.agents.set(String(agentId), { ...existing, ...agent, id: agentId });
+        }
+        return true;
+    }
+    async deleteAgents(agentIds) {
+        for (const id of agentIds) {
+            this.agents.delete(String(id));
+        }
+        return true;
+    }
+    async countAgents() {
+        return this.agents.size;
+    }
+    async cleanupAgents() {
+        // WHY no-op: InMemory adapter has no persistent storage, so no cleanup needed.
+        // Agents are automatically cleared when process restarts.
+    }
+    async getAgents() {
+        return Array.from(this.agents.values());
+    }
+    async ensureEmbeddingDimension(_dimension) {
+        // no-op
+    }
+    async transaction(callback, _options) {
+        return callback(this);
+    }
+    async queryEntities(_params) {
+        const matchedComponentsByEntity = new Map();
+        const hasComponentQuery = _params.componentType !== undefined ||
+            _params.componentDataFilter !== undefined ||
+            _params.worldId !== undefined;
+        if (hasComponentQuery) {
+            for (const component of this.components.values()) {
+                if (_params.agentId && component.agentId !== _params.agentId)
+                    continue;
+                if (_params.entityIds?.length &&
+                    !_params.entityIds.includes(component.entityId)) {
+                    continue;
+                }
+                if (_params.worldId !== undefined &&
+                    component.worldId !== _params.worldId) {
+                    continue;
+                }
+                if (_params.componentType !== undefined &&
+                    component.type !== _params.componentType) {
+                    continue;
+                }
+                if (_params.componentDataFilter !== undefined &&
+                    !dataContainsFilter(component.data, _params.componentDataFilter)) {
+                    continue;
+                }
+                const entityKey = String(component.entityId);
+                const bucket = matchedComponentsByEntity.get(entityKey) ?? [];
+                bucket.push(this.cloneComponent(component));
+                matchedComponentsByEntity.set(entityKey, bucket);
+            }
+        }
+        let entityIds = [];
+        if (matchedComponentsByEntity.size > 0) {
+            entityIds = Array.from(matchedComponentsByEntity.keys()).map(asUuid);
+        }
+        else if (_params.entityIds?.length) {
+            entityIds = [..._params.entityIds];
+        }
+        else {
+            return [];
+        }
+        const offset = _params.offset ?? 0;
+        const limit = _params.limit ?? entityIds.length;
+        entityIds = entityIds.slice(offset, offset + limit);
+        const entities = [];
+        for (const entityId of entityIds) {
+            const entity = this.entities.get(String(entityId));
+            if (!entity)
+                continue;
+            if (_params.agentId &&
+                entity.agentId &&
+                entity.agentId !== _params.agentId) {
+                continue;
+            }
+            const matchedComponents = matchedComponentsByEntity.get(String(entityId)) ?? [];
+            const components = _params.includeAllComponents
+                ? this.getStoredComponentsForEntity(entity.id)
+                : matchedComponents;
+            entities.push(this.attachComponents(entity, components));
+        }
+        return entities;
+    }
+    async getEntitiesForRooms(roomIds, _includeComponents) {
+        const result = [];
+        for (const roomId of roomIds) {
+            const participantSet = this.participantsByRoom.get(String(roomId));
+            const entities = [];
+            if (participantSet) {
+                for (const entityIdStr of participantSet) {
+                    const entity = this.entities.get(entityIdStr);
+                    if (entity) {
+                        entities.push(_includeComponents
+                            ? this.attachComponents(entity)
+                            : { ...entity });
+                    }
+                }
+            }
+            result.push({ roomId, entities });
+        }
+        return result;
+    }
+    async createEntities(entities) {
+        const ids = [];
+        for (const e of entities) {
+            if (!e.id)
+                throw new Error("Entity id is required");
+            this.entities.set(String(e.id), e);
+            ids.push(e.id);
+        }
+        return ids;
+    }
+    async upsertEntities(entities) {
+        // WHY simple set: For InMemory, upsert is just Map.set() which naturally
+        // handles both insert (new key) and update (existing key) cases.
+        for (const entity of entities) {
+            this.entities.set(String(entity.id), entity);
+        }
+    }
+    async searchEntitiesByName(params) {
+        // WHY O(N) scan: InMemory has no indexing, so we iterate all entities.
+        // Case-insensitive substring match on any name in the names array.
+        const lowerQuery = params.query.toLowerCase();
+        const limit = params.limit ?? 10;
+        const matches = [];
+        for (const entity of this.entities.values()) {
+            if (entity.agentId !== params.agentId)
+                continue;
+            const hasMatch = entity.names?.some((name) => name.toLowerCase().includes(lowerQuery));
+            if (hasMatch) {
+                matches.push(entity);
+                if (matches.length >= limit)
+                    break;
+            }
+        }
+        return matches;
+    }
+    async getEntitiesByNames(params) {
+        // WHY O(N) scan: InMemory has no indexing. Match ANY name in entity.names.
+        // Case-sensitive exact match (consistent with SQL implementations).
+        const nameSet = new Set(params.names);
+        const matches = [];
+        for (const entity of this.entities.values()) {
+            if (entity.agentId !== params.agentId)
+                continue;
+            const hasMatch = entity.names?.some((name) => nameSet.has(name));
+            if (hasMatch) {
+                matches.push(entity);
+            }
+        }
+        return matches;
+    }
+    async getComponentsByNaturalKeys(keys) {
+        return keys.map((key) => {
+            const componentId = this.componentIdsByNaturalKey.get(componentNaturalKey(key));
+            const component = componentId
+                ? this.components.get(componentId)
+                : undefined;
+            return component ? this.cloneComponent(component) : null;
+        });
+    }
+    async getComponentsForEntities(_entityIds, _worldId, _sourceEntityId) {
+        const components = [];
+        for (const entityId of _entityIds) {
+            components.push(...this.getStoredComponentsForEntity(entityId, {
+                worldId: _worldId,
+                sourceEntityId: _sourceEntityId,
+            }).map((component) => this.cloneComponent(component)));
+        }
+        return components;
+    }
+    // Batch entity methods
+    async getEntitiesByIds(entityIds) {
+        const entities = [];
+        for (const entityId of entityIds) {
+            const entity = this.entities.get(String(entityId));
+            if (entity)
+                entities.push({ ...entity });
+        }
+        return entities;
+    }
+    async updateEntities(entities) {
+        for (const entity of entities) {
+            this.entities.set(String(entity.id), entity);
+        }
+    }
+    async deleteEntities(entityIds) {
+        for (const entityId of entityIds) {
+            this.entities.delete(String(entityId));
+        }
+    }
+    // Batch component methods
+    async createComponents(components) {
+        for (const component of components) {
+            this.indexComponent(component);
+        }
+        return components.map((c) => c.id);
+    }
+    async getComponentsByIds(_componentIds) {
+        return _componentIds
+            .map((componentId) => this.components.get(String(componentId)))
+            .filter((component) => component !== undefined)
+            .map((component) => this.cloneComponent(component));
+    }
+    async updateComponents(_components) {
+        for (const component of _components) {
+            const existing = this.components.get(String(component.id));
+            if (existing) {
+                this.removeComponentIndexes(existing);
+            }
+            this.indexComponent(component);
+        }
+    }
+    async deleteComponents(_componentIds) {
+        for (const componentId of _componentIds) {
+            const existing = this.components.get(String(componentId));
+            this.removeComponentIndexes(existing);
+            this.components.delete(String(componentId));
+        }
+    }
+    async upsertComponents(_components, _options) {
+        for (const component of _components) {
+            const existingId = this.componentIdsByNaturalKey.get(componentNaturalKey(component));
+            if (!existingId) {
+                this.indexComponent(component);
+                continue;
+            }
+            const existing = this.components.get(existingId);
+            if (!existing) {
+                this.indexComponent(component);
+                continue;
+            }
+            this.removeComponentIndexes(existing);
+            this.indexComponent({
+                ...existing,
+                agentId: component.agentId,
+                roomId: component.roomId,
+                data: component.data,
+            });
+        }
+    }
+    async patchComponents(_updates, _options) {
+        // InMemory does not persist components; no-op for compatibility.
+    }
+    async getMemories(params) {
+        const effectiveLimit = params.limit ?? params.count ?? Infinity;
+        const roomId = params.roomId ?? DEFAULT_UUID;
+        const tableName = params.tableName ?? "messages";
+        let all = this.memoriesByRoom.get(roomTableKey(tableName, roomId)) ?? [];
+        // Filter by timestamp range (start/end are timestamps in milliseconds)
+        // This supports history compaction - only return messages after the compaction point
+        if (params.start !== undefined || params.end !== undefined) {
+            all = all.filter((memory) => {
+                const createdAt = memory.createdAt ?? 0;
+                if (params.start !== undefined && createdAt < params.start) {
+                    return false;
+                }
+                if (params.end !== undefined && createdAt > params.end) {
+                    return false;
+                }
+                return true;
+            });
+        }
+        // WHY: In-memory metadata filtering uses deep equality check for each
+        // filter key. This is less efficient than SQL containment operators but
+        // correct for nested objects/arrays. Matches PG @> and MySQL JSON_CONTAINS semantics.
+        if (params.metadata) {
+            const filterMeta = params.metadata;
+            all = all.filter((memory) => {
+                if (!memory.metadata)
+                    return false;
+                const memMeta = memory.metadata;
+                // Check if memory.metadata contains all key-value pairs from params.metadata
+                for (const [key, value] of Object.entries(filterMeta)) {
+                    if (!(key in memMeta))
+                        return false;
+                    // Deep equality check for nested objects/arrays
+                    if (JSON.stringify(memMeta[key]) !== JSON.stringify(value)) {
+                        return false;
+                    }
+                }
+                return true;
+            });
+        }
+        // Match plugin-sql ordering: newest first, then id desc as tiebreaker.
+        // Without this, `count: N` returns the N oldest instead of the N newest,
+        // which silently diverges from plugin-sql once a room exceeds N memories.
+        all = all.slice().sort((a, b) => {
+            const ta = a.createdAt ?? 0;
+            const tb = b.createdAt ?? 0;
+            if (ta !== tb)
+                return tb - ta;
+            return String(b.id ?? "").localeCompare(String(a.id ?? ""));
+        });
+        const offset = params.offset ?? 0;
+        return all.slice(offset, offset + (effectiveLimit === Infinity ? all.length : effectiveLimit));
+    }
+    async getMemoriesByIds(ids) {
+        const out = [];
+        for (const id of ids) {
+            const m = this.memoriesById.get(String(id));
+            if (m)
+                out.push(m);
+        }
+        return out;
+    }
+    async getMemoriesByRoomIds(params) {
+        const limit = params.limit ?? 20;
+        const out = [];
+        for (const rid of params.roomIds) {
+            const list = this.memoriesByRoom.get(roomTableKey(params.tableName, rid)) ?? [];
+            for (const m of list) {
+                out.push(m);
+                if (out.length >= limit)
+                    return out;
+            }
+        }
+        return out;
+    }
+    async getCachedEmbeddings() {
+        return [];
+    }
+    async getLogs(params) {
+        const effectiveLimit = params.limit ?? 10;
+        let filtered = this.logs;
+        // Filter by entityId if provided
+        if (params.entityId !== undefined) {
+            filtered = filtered.filter((log) => log.entityId === params.entityId);
+        }
+        // Filter by roomId if provided
+        if (params.roomId !== undefined) {
+            filtered = filtered.filter((log) => log.roomId === params.roomId);
+        }
+        // Filter by type if provided
+        if (params.type !== undefined) {
+            filtered = filtered.filter((log) => log.type === params.type);
+        }
+        // Apply offset (skip first N results)
+        const offset = params.offset ?? 0;
+        filtered = filtered.slice(offset);
+        // Apply limit (limit results)
+        filtered = filtered.slice(0, effectiveLimit);
+        return filtered;
+    }
+    // Batch log methods
+    async getLogsByIds(logIds) {
+        const idSet = new Set(logIds.map(String));
+        return this.logs.filter((l) => idSet.has(String(l.id)));
+    }
+    async createLogs(params) {
+        for (const param of params) {
+            const id = typeof crypto !== "undefined" && typeof crypto.randomUUID === "function"
+                ? crypto.randomUUID()
+                : `${Date.now()}-${Math.random().toString(16).slice(2)}`;
+            this.logs.push({
+                id: asUuid(id),
+                createdAt: new Date(),
+                entityId: param.entityId,
+                roomId: param.roomId,
+                type: param.type,
+                body: param.body,
+            });
+        }
+    }
+    async updateLogs(logs) {
+        for (const { id, updates } of logs) {
+            const log = this.logs.find((l) => String(l.id) === String(id));
+            if (log) {
+                Object.assign(log, updates);
+            }
+        }
+    }
+    async deleteLogs(logIds) {
+        const idSet = new Set(logIds.map(String));
+        this.logs = this.logs.filter((l) => !idSet.has(String(l.id)));
+    }
+    async searchMemories() {
+        return [];
+    }
+    // Batch memory methods
+    async createMemories(memories) {
+        const ids = [];
+        for (const { memory, tableName } of memories) {
+            const gen = typeof crypto !== "undefined" && typeof crypto.randomUUID === "function"
+                ? crypto.randomUUID()
+                : `${Date.now()}-${Math.random().toString(16).slice(2)}`;
+            const id = memory.id ? String(memory.id) : gen;
+            const stored = {
+                ...memory,
+                id: asUuid(id),
+            };
+            this.memoriesById.set(id, stored);
+            const roomId = memory.roomId ?? DEFAULT_UUID;
+            const key = roomTableKey(tableName, roomId);
+            const list = this.memoriesByRoom.get(key) ?? [];
+            list.push(stored);
+            this.memoriesByRoom.set(key, list);
+            ids.push(asUuid(id));
+        }
+        return ids;
+    }
+    async updateMemories(memories) {
+        for (const memory of memories) {
+            const existing = this.memoriesById.get(String(memory.id));
+            if (!existing) {
+                // WHY: Changed from returning false to skipping. Update failures should
+                // ideally throw, but silently skipping non-existent memories maintains
+                // backward compatibility with callers that may not check return values.
+                continue;
+            }
+            const merged = { ...existing, ...memory };
+            this.memoriesById.set(String(memory.id), merged);
+            // Update reference in memoriesByRoom to keep consistency
+            const oldRoomId = existing.roomId ?? DEFAULT_UUID;
+            const newRoomId = merged.roomId ?? DEFAULT_UUID;
+            for (const [key, list] of this.memoriesByRoom) {
+                const idx = list.findIndex((m) => String(m.id) === String(memory.id));
+                if (idx !== -1) {
+                    if (String(oldRoomId) !== String(newRoomId)) {
+                        const tableName = key.split(":")[0];
+                        list.splice(idx, 1);
+                        const newKey = roomTableKey(tableName, newRoomId);
+                        const newList = this.memoriesByRoom.get(newKey) ?? [];
+                        newList.push(merged);
+                        this.memoriesByRoom.set(newKey, newList);
+                    }
+                    else {
+                        list[idx] = merged;
+                    }
+                    break;
+                }
+            }
+        }
+    }
+    async upsertMemories(memories, _options) {
+        for (const { memory, tableName } of memories) {
+            const id = memory.id;
+            if (id == null) {
+                await this.createMemories([{ memory, tableName }]);
+                continue;
+            }
+            if (this.memoriesById.has(String(id))) {
+                await this.updateMemories([{ ...memory, id }]);
+            }
+            else {
+                await this.createMemories([{ memory, tableName }]);
+            }
+        }
+    }
+    async deleteMemories(memoryIds) {
+        const idSet = new Set(memoryIds.map(String));
+        for (const id of memoryIds) {
+            this.memoriesById.delete(String(id));
+        }
+        // Clean up memoriesByRoom references
+        for (const [key, list] of this.memoriesByRoom) {
+            const filtered = list.filter((m) => !idSet.has(String(m.id)));
+            if (filtered.length === 0) {
+                this.memoriesByRoom.delete(key);
+            }
+            else if (filtered.length !== list.length) {
+                this.memoriesByRoom.set(key, filtered);
+            }
+        }
+    }
+    async deleteAllMemories(roomIds, tableName) {
+        for (const roomId of roomIds) {
+            const key = roomTableKey(tableName, roomId);
+            const memories = this.memoriesByRoom.get(key) ?? [];
+            for (const mem of memories) {
+                this.memoriesById.delete(String(mem.id));
+            }
+            this.memoriesByRoom.delete(key);
+        }
+    }
+    async countMemories(params) {
+        const roomIds = params.roomIds ?? [];
+        const tbl = params.tableName ?? "messages";
+        const u = params.unique;
+        let total = 0;
+        if (roomIds.length === 0) {
+            // No room filter: count all memories matching tableName and other filters (consistent with SQL/store behavior)
+            const prefix = `${tbl}:`;
+            for (const [key, memories] of this.memoriesByRoom) {
+                if (!key.startsWith(prefix))
+                    continue;
+                let list = memories;
+                if (params.entityId)
+                    list = list.filter((m) => m.entityId === params.entityId);
+                if (params.agentId)
+                    list = list.filter((m) => m.agentId === params.agentId);
+                total += u ? list.filter((m) => m.unique).length : list.length;
+            }
+            return total;
+        }
+        for (const roomId of roomIds) {
+            const key = roomTableKey(tbl, roomId);
+            const memories = this.memoriesByRoom.get(key) ?? [];
+            let list = memories;
+            if (params.entityId)
+                list = list.filter((m) => m.entityId === params.entityId);
+            if (params.agentId)
+                list = list.filter((m) => m.agentId === params.agentId);
+            total += u ? list.filter((m) => m.unique).length : list.length;
+        }
+        return total;
+    }
+    // Batch world methods
+    async getWorldsByIds(worldIds) {
+        const worlds = [];
+        for (const id of worldIds) {
+            const world = this.worlds.get(String(id));
+            if (world) {
+                worlds.push(world);
+            }
+        }
+        return worlds;
+    }
+    async createWorlds(worlds) {
+        const ids = [];
+        for (const world of worlds) {
+            this.worlds.set(String(world.id), world);
+            ids.push(world.id);
+        }
+        return ids;
+    }
+    async upsertWorlds(worlds) {
+        // WHY simple set: Map.set() handles both insert and update atomically.
+        for (const world of worlds) {
+            this.worlds.set(String(world.id), world);
+        }
+    }
+    async deleteWorlds(worldIds) {
+        for (const id of worldIds) {
+            this.worlds.delete(String(id));
+        }
+    }
+    async updateWorlds(worlds) {
+        for (const world of worlds) {
+            this.worlds.set(String(world.id), world);
+        }
+    }
+    async getAllWorlds() {
+        return Array.from(this.worlds.values());
+    }
+    // Batch room methods
+    async updateRooms(rooms) {
+        for (const room of rooms) {
+            this.rooms.set(String(room.id), room);
+        }
+    }
+    async deleteRooms(roomIds) {
+        for (const id of roomIds) {
+            this.rooms.delete(String(id));
+        }
+    }
+    async getRoomsByIds(roomIds) {
+        const out = [];
+        for (const id of roomIds) {
+            const r = this.rooms.get(String(id));
+            if (r)
+                out.push(r);
+        }
+        return out;
+    }
+    async createRooms(rooms) {
+        const ids = [];
+        for (const r of rooms) {
+            this.rooms.set(String(r.id), r);
+            ids.push(r.id);
+        }
+        return ids;
+    }
+    async upsertRooms(rooms) {
+        // WHY simple set: InMemory upsert is just Map.set() - idempotent by nature.
+        for (const room of rooms) {
+            this.rooms.set(String(room.id), room);
+        }
+    }
+    async getRoomsForParticipants(entityIds) {
+        const out = new Set();
+        for (const id of entityIds) {
+            const set = this.roomsByParticipant.get(String(id));
+            if (!set)
+                continue;
+            for (const roomId of set.values())
+                out.add(roomId);
+        }
+        return Array.from(out.values()).map(asUuid);
+    }
+    async getRoomsByWorlds(worldIds, limit, offset) {
+        let out = [];
+        for (const room of this.rooms.values()) {
+            if (room.worldId && worldIds.includes(room.worldId)) {
+                out.push(room);
+            }
+        }
+        const off = offset ?? 0;
+        out = out.slice(off);
+        if (limit != null)
+            out = out.slice(0, limit);
+        return out;
+    }
+    async getParticipantsForEntities(entityIds) {
+        const out = [];
+        for (const entityId of entityIds) {
+            const entity = this.entities.get(String(entityId));
+            if (entity)
+                out.push({ id: entityId, entity });
+        }
+        return out;
+    }
+    async getParticipantsForRooms(roomIds) {
+        const result = [];
+        for (const roomId of roomIds) {
+            const set = this.participantsByRoom.get(String(roomId));
+            const entityIds = set ? Array.from(set.values()).map(asUuid) : [];
+            result.push({ roomId, entityIds });
+        }
+        return result;
+    }
+    async createRoomParticipants(entityIds, roomId) {
+        // WHY: InMemory doesn't have real participant record IDs (it's just a set).
+        // We generate UUIDs to match the interface contract, even though they're not stored.
+        const roomKey = String(roomId);
+        const participants = this.participantsByRoom.get(roomKey) ?? new Set();
+        const ids = [];
+        for (const eid of entityIds) {
+            const entityKey = String(eid);
+            participants.add(entityKey);
+            const rooms = this.roomsByParticipant.get(entityKey) ?? new Set();
+            rooms.add(roomKey);
+            this.roomsByParticipant.set(entityKey, rooms);
+            // Generate a synthetic ID for this participant record
+            ids.push(`${roomId}:${eid}`);
+        }
+        this.participantsByRoom.set(roomKey, participants);
+        return ids;
+    }
+    // Batch participant methods
+    async deleteParticipants(participants) {
+        for (const { entityId, roomId } of participants) {
+            const roomKey = String(roomId);
+            const entityKey = String(entityId);
+            const roomParticipants = this.participantsByRoom.get(roomKey);
+            if (roomParticipants) {
+                roomParticipants.delete(entityKey);
+                if (roomParticipants.size === 0)
+                    this.participantsByRoom.delete(roomKey);
+            }
+            const rooms = this.roomsByParticipant.get(entityKey);
+            if (rooms) {
+                rooms.delete(roomKey);
+                if (rooms.size === 0)
+                    this.roomsByParticipant.delete(entityKey);
+            }
+            this.participantUserState.delete(`${roomKey}:${entityKey}`);
+        }
+        return true;
+    }
+    async updateParticipants(participants) {
+        // InMemory adapter stores participants as just sets of IDs, so we can only
+        // update roomState (which is stored separately in participantUserState).
+        // Metadata updates are not supported in this simple adapter.
+        for (const { entityId, roomId, updates } of participants) {
+            const roomState = updates.roomState;
+            if (roomState !== undefined) {
+                const key = `${String(roomId)}:${String(entityId)}`;
+                this.participantUserState.set(key, roomState);
+            }
+        }
+    }
+    async areRoomParticipants(pairs) {
+        return pairs.map(({ roomId, entityId }) => {
+            const set = this.participantsByRoom.get(String(roomId));
+            return set ? set.has(String(entityId)) : false;
+        });
+    }
+    async getParticipantUserStates(pairs) {
+        return pairs.map(({ roomId, entityId }) => {
+            const key = `${String(roomId)}:${String(entityId)}`;
+            return this.participantUserState.get(key) ?? null;
+        });
+    }
+    async updateParticipantUserStates(updates) {
+        for (const { roomId, entityId, state } of updates) {
+            const key = `${String(roomId)}:${String(entityId)}`;
+            this.participantUserState.set(key, state);
+        }
+    }
+    async getRelationshipsByPairs(_pairs) {
+        return _pairs.map(() => null);
+    }
+    async getRelationships(_params) {
+        return [];
+    }
+    // Batch relationship methods
+    async createRelationships(relationships) {
+        // WHY: InMemory adapter doesn't actually store relationships, but we return
+        // placeholder IDs to match the interface contract.
+        return relationships.map(() => {
+            const gen = typeof crypto !== "undefined" && typeof crypto.randomUUID === "function"
+                ? crypto.randomUUID()
+                : `${Date.now()}-${Math.random().toString(16).slice(2)}`;
+            return gen;
+        });
+    }
+    async getRelationshipsByIds(_relationshipIds) {
+        return [];
+    }
+    async updateRelationships(_relationships) {
+        // no-op
+    }
+    async deleteRelationships(_relationshipIds) {
+        // no-op
+    }
+    // Batch cache methods
+    async getCaches(keys) {
+        const result = new Map();
+        for (const key of keys) {
+            const raw = this.cache.get(key);
+            if (raw === undefined)
+                continue;
+            result.set(key, JSON.parse(raw));
+        }
+        return result;
+    }
+    async setCaches(entries) {
+        for (const entry of entries) {
+            this.cache.set(entry.key, JSON.stringify(entry.value));
+        }
+        return true;
+    }
+    async deleteCaches(keys) {
+        for (const key of keys) {
+            this.cache.delete(key);
+        }
+        return true;
+    }
+    async getTasks(params) {
+        if (params.agentIds.length === 0)
+            return [];
+        const all = Array.from(this.tasks.values());
+        let filtered = all.filter((t) => {
+            if (params.roomId && t.roomId !== params.roomId)
+                return false;
+            if (params.entityId && t.entityId !== params.entityId)
+                return false;
+            if (t.agentId == null || !params.agentIds.includes(t.agentId))
+                return false;
+            if (params.tags && params.tags.length > 0) {
+                for (const tag of params.tags) {
+                    if (!t.tags.includes(tag))
+                        return false;
+                }
+            }
+            return true;
+        });
+        // WHY: Apply pagination to limit result size. Previously returned ALL matching tasks.
+        const offset = params.offset ?? 0;
+        filtered = filtered.slice(offset);
+        if (params.limit) {
+            filtered = filtered.slice(0, params.limit);
+        }
+        return filtered;
+    }
+    async getTasksByName(name) {
+        return Array.from(this.tasks.values()).filter((t) => t.name === name);
+    }
+    // Batch task methods
+    async createTasks(tasks) {
+        const ids = [];
+        for (const task of tasks) {
+            const gen = typeof crypto !== "undefined" && typeof crypto.randomUUID === "function"
+                ? crypto.randomUUID()
+                : `${Date.now()}-${Math.random().toString(16).slice(2)}`;
+            const id = task.id ? String(task.id) : gen;
+            const taskId = asUuid(id);
+            const stored = { ...task, id: taskId };
+            this.tasks.set(id, stored);
+            ids.push(taskId);
+        }
+        return ids;
+    }
+    async getTasksByIds(taskIds) {
+        const tasks = [];
+        for (const taskId of taskIds) {
+            const task = this.tasks.get(String(taskId));
+            if (task)
+                tasks.push(task);
+        }
+        return tasks;
+    }
+    async updateTasks(updates) {
+        for (const update of updates) {
+            const existing = this.tasks.get(String(update.id));
+            if (!existing)
+                continue;
+            this.tasks.set(String(update.id), {
+                ...existing,
+                ...update.task,
+                id: update.id,
+            });
+        }
+    }
+    async deleteTasks(taskIds) {
+        for (const taskId of taskIds) {
+            this.tasks.delete(String(taskId));
+        }
+    }
+    async getMemoriesByWorldId(params) {
+        const worldIds = params.worldIds ?? [];
+        if (worldIds.length === 0)
+            return [];
+        const rooms = await this.getRoomsByWorlds(worldIds);
+        const roomIds = rooms.map((r) => r.id);
+        const effectiveLimit = params.limit ?? 50;
+        const out = [];
+        for (const rid of roomIds) {
+            if (params.tableName) {
+                const list = this.memoriesByRoom.get(roomTableKey(params.tableName, rid)) ?? [];
+                for (const m of list) {
+                    out.push(m);
+                    if (out.length >= effectiveLimit)
+                        return out;
+                }
+                continue;
+            }
+            for (const [key, list] of this.memoriesByRoom.entries()) {
+                if (!key.endsWith(`:${String(rid)}`))
+                    continue;
+                for (const m of list) {
+                    out.push(m);
+                    if (out.length >= effectiveLimit)
+                        return out;
+                }
+            }
+        }
+        return out;
+    }
+    async deleteRoomsByWorldIds(worldIds) {
+        for (const worldId of worldIds) {
+            const rooms = await this.getRoomsByWorlds([worldId]);
+            for (const room of rooms) {
+                const roomKey = String(room.id);
+                this.rooms.delete(roomKey);
+                for (const key of this.memoriesByRoom.keys()) {
+                    if (key.endsWith(`:${roomKey}`))
+                        this.memoriesByRoom.delete(key);
+                }
+                this.participantsByRoom.delete(roomKey);
+                for (const [entityKey, roomSet] of this.roomsByParticipant.entries()) {
+                    if (roomSet.delete(roomKey) && roomSet.size === 0)
+                        this.roomsByParticipant.delete(entityKey);
+                }
+                for (const key of this.participantUserState.keys()) {
+                    if (key.startsWith(`${roomKey}:`))
+                        this.participantUserState.delete(key);
+                }
+            }
+        }
+    }
+    // ===============================
+    // Pairing Methods
+    // ===============================
+    async getPairingRequests(queries) {
+        const result = [];
+        for (const { channel, agentId } of queries) {
+            const requests = [];
+            for (const request of this.pairingRequests.values()) {
+                if (request.channel === channel && request.agentId === agentId) {
+                    requests.push(request);
+                }
+            }
+            requests.sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
+            result.push({ channel, agentId, requests });
+        }
+        return result;
+    }
+    // Batch pairing request methods
+    async createPairingRequests(requests) {
+        const ids = [];
+        for (const request of requests) {
+            const gen = typeof crypto !== "undefined" && typeof crypto.randomUUID === "function"
+                ? crypto.randomUUID()
+                : `${Date.now()}-${Math.random().toString(16).slice(2)}`;
+            const id = request.id ? String(request.id) : gen;
+            const stored = { ...request, id: asUuid(id) };
+            this.pairingRequests.set(id, stored);
+            ids.push(asUuid(id));
+        }
+        return ids;
+    }
+    async updatePairingRequests(requests) {
+        for (const request of requests) {
+            const existing = this.pairingRequests.get(String(request.id));
+            if (existing) {
+                this.pairingRequests.set(String(request.id), {
+                    ...existing,
+                    ...request,
+                });
+            }
+        }
+    }
+    async deletePairingRequests(ids) {
+        for (const id of ids) {
+            this.pairingRequests.delete(String(id));
+        }
+    }
+    async getPairingAllowlists(queries) {
+        const result = [];
+        for (const { channel, agentId } of queries) {
+            const entries = [];
+            for (const entry of this.pairingAllowlist.values()) {
+                if (entry.channel === channel && entry.agentId === agentId) {
+                    entries.push(entry);
+                }
+            }
+            entries.sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
+            result.push({ channel, agentId, entries });
+        }
+        return result;
+    }
+    // Batch pairing allowlist methods
+    async createPairingAllowlistEntries(entries) {
+        const ids = [];
+        for (const entry of entries) {
+            const gen = typeof crypto !== "undefined" && typeof crypto.randomUUID === "function"
+                ? crypto.randomUUID()
+                : `${Date.now()}-${Math.random().toString(16).slice(2)}`;
+            const id = entry.id ? String(entry.id) : gen;
+            const stored = { ...entry, id: asUuid(id) };
+            this.pairingAllowlist.set(id, stored);
+            ids.push(asUuid(id));
+        }
+        return ids;
+    }
+    async updatePairingAllowlistEntries(entries) {
+        for (const entry of entries) {
+            if (!entry.id)
+                continue;
+            const id = String(entry.id);
+            const existing = this.pairingAllowlist.get(id);
+            if (existing) {
+                this.pairingAllowlist.set(id, { ...existing, ...entry });
+            }
+        }
+    }
+    async deletePairingAllowlistEntries(ids) {
+        for (const id of ids) {
+            this.pairingAllowlist.delete(String(id));
+        }
+    }
+}