agent-world 0.11.1 → 0.12.0

package/dist/core/storage/storage-factory.js

@@ -0,0 +1,794 @@
+import { validateAgentMessageIds } from './validation.js';
+import { createCategoryLogger } from '../logger.js';
+import { isNodeEnvironment } from '../utils.js';
+import * as path from 'path';
+const logger = createCategoryLogger('storage.init');
+import * as fs from 'fs';
+/**
+ * Creates storage wrappers that implement StorageAPI and delegate to storage instance.
+ * Provides unified interface across all storage backends with graceful NoOp fallbacks.
+ */
+export function createStorageWrappers(storageInstance) {
+    const wrappers = {
+        // World operations
+        async saveWorld(worldData) {
+            if (!storageInstance)
+                return;
+            return storageInstance.saveWorld(worldData);
+        },
+        async loadWorld(worldId) {
+            if (!storageInstance)
+                return null;
+            return storageInstance.loadWorld(worldId);
+        },
+        async deleteWorld(worldId) {
+            if (!storageInstance)
+                return false;
+            return storageInstance.deleteWorld(worldId);
+        },
+        async listWorlds() {
+            if (!storageInstance)
+                return [];
+            return storageInstance.listWorlds();
+        },
+        async worldExists(worldId) {
+            if (!storageInstance)
+                return false;
+            try {
+                const world = await storageInstance.loadWorld(worldId);
+                return !!world;
+            }
+            catch {
+                return false;
+            }
+        },
+        async getMemory(worldId, chatId) {
+            if (!storageInstance)
+                return [];
+            if ('getMemory' in storageInstance) {
+                return storageInstance.getMemory(worldId, chatId);
+            }
+            return [];
+        },
+        // Agent operations
+        async saveAgent(worldId, agent) {
+            if (!storageInstance)
+                return;
+            return storageInstance.saveAgent(worldId, agent);
+        },
+        async saveAgentMemory(worldId, agentId, memory) {
+            if (!storageInstance)
+                return;
+            // Call the storage instance's saveAgentMemory directly instead of load-modify-save
+            if ('saveAgentMemory' in storageInstance && typeof storageInstance.saveAgentMemory === 'function') {
+                return storageInstance.saveAgentMemory(worldId, agentId, memory);
+            }
+            // Fallback to load-modify-save for storages without dedicated saveAgentMemory
+            const agent = await storageInstance.loadAgent(worldId, agentId);
+            if (agent) {
+                agent.memory = memory;
+                return storageInstance.saveAgent(worldId, agent);
+            }
+        },
+        async loadAgent(worldId, agentId) {
+            if (!storageInstance)
+                return null;
+            return storageInstance.loadAgent(worldId, agentId);
+        },
+        async loadAgentWithRetry(worldId, agentId, options) {
+            if (!storageInstance)
+                return null;
+            return storageInstance.loadAgent(worldId, agentId);
+        },
+        async deleteAgent(worldId, agentId) {
+            if (!storageInstance)
+                return false;
+            return storageInstance.deleteAgent(worldId, agentId);
+        },
+        async listAgents(worldId) {
+            if (!storageInstance)
+                return [];
+            return storageInstance.listAgents(worldId);
+        },
+        async agentExists(worldId, agentId) {
+            if (!storageInstance)
+                return false;
+            try {
+                const agent = await storageInstance.loadAgent(worldId, agentId);
+                return !!agent;
+            }
+            catch {
+                return false;
+            }
+        },
+        // Chat operations
+        async saveChatData(worldId, chat) {
+            if (!storageInstance)
+                return;
+            try {
+                return await storageInstance.saveChatData(worldId, chat);
+            }
+            catch (err) {
+                throw new Error(`Failed to save chat history: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        },
+        async loadChatData(worldId, chatId) {
+            if (!storageInstance)
+                return null;
+            try {
+                return await storageInstance.loadChatData(worldId, chatId);
+            }
+            catch (err) {
+                throw new Error(`Failed to load chat history: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        },
+        async deleteChatData(worldId, chatId) {
+            if (!storageInstance)
+                return false;
+            try {
+                return await storageInstance.deleteChatData(worldId, chatId);
+            }
+            catch (err) {
+                throw new Error(`Failed to delete chat history: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        },
+        async listChats(worldId) {
+            if (!storageInstance)
+                return [];
+            try {
+                return await storageInstance.listChats(worldId);
+            }
+            catch (err) {
+                throw new Error(`Failed to list chats: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        },
+        async updateChatData(worldId, chatId, updates) {
+            if (!storageInstance)
+                return null;
+            try {
+                return await storageInstance.updateChatData(worldId, chatId, updates);
+            }
+            catch (err) {
+                throw new Error(`Failed to update chat history: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        },
+        async updateChatNameIfCurrent(worldId, chatId, expectedName, nextName) {
+            if (!storageInstance)
+                return false;
+            if (typeof storageInstance.updateChatNameIfCurrent === 'function') {
+                return storageInstance.updateChatNameIfCurrent(worldId, chatId, expectedName, nextName);
+            }
+            // Fallback path for backends without compare-and-set support.
+            const current = await storageInstance.loadChatData(worldId, chatId);
+            if (!current || current.name !== expectedName) {
+                return false;
+            }
+            const updated = await storageInstance.updateChatData(worldId, chatId, { name: nextName });
+            return !!updated;
+        },
+        async saveWorldChat(worldId, chatId, chat) {
+            if (!storageInstance)
+                return;
+            try {
+                return await storageInstance.saveWorldChat(worldId, chatId, chat);
+            }
+            catch (err) {
+                throw new Error(`Failed to save world chat: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        },
+        async loadWorldChat(worldId, chatId) {
+            if (!storageInstance)
+                return null;
+            try {
+                return await storageInstance.loadWorldChat(worldId, chatId);
+            }
+            catch (err) {
+                throw new Error(`Failed to load world chat: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        },
+        async loadWorldChatFull(worldId, chatId) {
+            if (!storageInstance)
+                return null;
+            try {
+                return await storageInstance.loadWorldChatFull(worldId, chatId);
+            }
+            catch (err) {
+                throw new Error(`Failed to load full world chat: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        },
+        async restoreFromWorldChat(worldId, chat) {
+            if (!storageInstance)
+                return false;
+            try {
+                return await storageInstance.restoreFromWorldChat(worldId, chat);
+            }
+            catch (err) {
+                throw new Error(`Failed to restore from world chat: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        },
+        async archiveMemory(worldId, agentId, memory) {
+            if (!storageInstance)
+                return;
+            if ('archiveAgentMemory' in storageInstance) {
+                return storageInstance.archiveAgentMemory(worldId, agentId, memory);
+            }
+        },
+        async deleteMemoryByChatId(worldId, chatId) {
+            if (!storageInstance)
+                return 0;
+            if ('deleteMemoryByChatId' in storageInstance) {
+                return storageInstance.deleteMemoryByChatId(worldId, chatId);
+            }
+            return 0;
+        },
+        // Batch operations
+        async saveAgentsBatch(worldId, agents) {
+            if (!storageInstance)
+                return;
+            if ('saveAgentsBatch' in storageInstance) {
+                return storageInstance.saveAgentsBatch(worldId, agents);
+            }
+            else {
+                for (const agent of agents) {
+                    await this.saveAgent(worldId, agent);
+                }
+            }
+        },
+        async loadAgentsBatch(worldId, agentIds) {
+            if (!storageInstance)
+                return [];
+            if ('loadAgentsBatch' in storageInstance) {
+                return storageInstance.loadAgentsBatch(worldId, agentIds);
+            }
+            else {
+                const agents = [];
+                for (const agentId of agentIds) {
+                    const agent = await this.loadAgent(worldId, agentId);
+                    if (agent)
+                        agents.push(agent);
+                }
+                return agents;
+            }
+        },
+        // Integrity operations
+        async validateIntegrity(worldId, agentId) {
+            if (!storageInstance)
+                return false;
+            if ('validateIntegrity' in storageInstance) {
+                return storageInstance.validateIntegrity(worldId, agentId);
+            }
+            else {
+                try {
+                    if (agentId) {
+                        const agent = await this.loadAgent(worldId, agentId);
+                        return !!agent;
+                    }
+                    else {
+                        const world = await this.loadWorld(worldId);
+                        return !!world;
+                    }
+                }
+                catch {
+                    return false;
+                }
+            }
+        },
+        async repairData(worldId, agentId) {
+            if (!storageInstance)
+                return false;
+            if ('repairData' in storageInstance) {
+                return storageInstance.repairData(worldId, agentId);
+            }
+            else {
+                try {
+                    if (agentId) {
+                        await this.loadAgent(worldId, agentId);
+                    }
+                    else {
+                        await this.loadWorld(worldId);
+                    }
+                    return true;
+                }
+                catch {
+                    return false;
+                }
+            }
+        }
+    };
+    // Expose eventStorage if it exists on the storage instance
+    if (storageInstance && storageInstance.eventStorage) {
+        wrappers.eventStorage = storageInstance.eventStorage;
+    }
+    return wrappers;
+}
+// File storage adapter with dynamic module loading
+function createFileStorageAdapter(rootPath) {
+    let worldStorage;
+    let agentStorage;
+    async function ensureModulesLoaded() {
+        if (!worldStorage || !agentStorage) {
+            if (!isNodeEnvironment()) {
+                throw new Error('File storage not available in browser environment');
+            }
+            try {
+                worldStorage = await import('./world-storage.js');
+                agentStorage = await import('./agent-storage.js');
+            }
+            catch (error) {
+                throw new Error('Failed to load storage modules: ' + (error instanceof Error ? error.message : error));
+            }
+        }
+    }
+    return {
+        async saveWorld(worldData) {
+            await ensureModulesLoaded();
+            if (worldStorage?.saveWorld) {
+                return worldStorage.saveWorld(rootPath, worldData);
+            }
+        },
+        async loadWorld(worldId) {
+            await ensureModulesLoaded();
+            if (worldStorage?.loadWorld) {
+                return worldStorage.loadWorld(rootPath, worldId);
+            }
+            return null;
+        },
+        async deleteWorld(worldId) {
+            await ensureModulesLoaded();
+            if (worldStorage?.deleteWorld) {
+                return worldStorage.deleteWorld(rootPath, worldId);
+            }
+            return false;
+        },
+        async listWorlds() {
+            await ensureModulesLoaded();
+            if (worldStorage?.listWorlds) {
+                return worldStorage.listWorlds(rootPath);
+            }
+            return [];
+        },
+        async getMemory(worldId, chatId) {
+            await ensureModulesLoaded();
+            if (worldStorage?.getMemory) {
+                return worldStorage.getMemory(rootPath, worldId, chatId);
+            }
+            return [];
+        },
+        async saveAgent(worldId, agent) {
+            await ensureModulesLoaded();
+            // Auto-migrate legacy messages without messageId
+            const migrated = validateAgentMessageIds(agent);
+            if (migrated) {
+                logger.info('Auto-migrated agent messages with missing messageIds', {
+                    agentId: agent.id,
+                    worldId,
+                    messageCount: agent.memory.length
+                });
+            }
+            if (agentStorage?.saveAgent) {
+                return agentStorage.saveAgent(rootPath, worldId, agent);
+            }
+        },
+        async loadAgent(worldId, agentId) {
+            await ensureModulesLoaded();
+            if (agentStorage?.loadAgent) {
+                const agent = await agentStorage.loadAgent(rootPath, worldId, agentId);
+                if (agent) {
+                    // Auto-migrate on load if needed
+                    const migrated = validateAgentMessageIds(agent);
+                    if (migrated) {
+                        logger.info('Auto-migrated agent messages on load', {
+                            agentId,
+                            worldId,
+                            messageCount: agent.memory.length
+                        });
+                        // Save back the migrated agent
+                        if (agentStorage?.saveAgent) {
+                            await agentStorage.saveAgent(rootPath, worldId, agent);
+                        }
+                    }
+                }
+                return agent;
+            }
+            return null;
+        },
+        async deleteAgent(worldId, agentId) {
+            await ensureModulesLoaded();
+            if (agentStorage?.deleteAgent) {
+                return agentStorage.deleteAgent(rootPath, worldId, agentId);
+            }
+            return false;
+        },
+        async listAgents(worldId) {
+            await ensureModulesLoaded();
+            if (agentStorage?.listAgents) {
+                return agentStorage.listAgents(rootPath, worldId);
+            }
+            return [];
+        },
+        async saveAgentsBatch(worldId, agents) {
+            await ensureModulesLoaded();
+            if (agentStorage?.saveAgent) {
+                for (const agent of agents) {
+                    await agentStorage.saveAgent(rootPath, worldId, agent);
+                }
+            }
+        },
+        async loadAgentsBatch(worldId, agentIds) {
+            await ensureModulesLoaded();
+            if (agentStorage?.loadAgent) {
+                const agents = [];
+                for (const agentId of agentIds) {
+                    const agent = await agentStorage.loadAgent(rootPath, worldId, agentId);
+                    if (agent)
+                        agents.push(agent);
+                }
+                return agents;
+            }
+            return [];
+        },
+        async validateIntegrity(worldId, agentId) {
+            await ensureModulesLoaded();
+            if (agentId) {
+                if (agentStorage?.validateAgentIntegrity) {
+                    const result = await agentStorage.validateAgentIntegrity(rootPath, worldId, agentId);
+                    return result.isValid;
+                }
+            }
+            else {
+                if (worldStorage?.worldExists) {
+                    return worldStorage.worldExists(rootPath, worldId);
+                }
+            }
+            return false;
+        },
+        async repairData(worldId, agentId) {
+            await ensureModulesLoaded();
+            if (agentId) {
+                if (agentStorage?.repairAgentData) {
+                    return agentStorage.repairAgentData(rootPath, worldId, agentId);
+                }
+            }
+            return false;
+        },
+        async saveChatData(worldId, chat) {
+            await ensureModulesLoaded();
+            if (worldStorage?.saveChatData) {
+                return worldStorage.saveChatData(rootPath, worldId, chat);
+            }
+        },
+        async loadChatData(worldId, chatId) {
+            await ensureModulesLoaded();
+            if (worldStorage?.loadChatData) {
+                return worldStorage.loadChatData(rootPath, worldId, chatId);
+            }
+            return null;
+        },
+        async deleteChatData(worldId, chatId) {
+            await ensureModulesLoaded();
+            if (worldStorage?.deleteChatData) {
+                return worldStorage.deleteChatData(rootPath, worldId, chatId);
+            }
+            return false;
+        },
+        async listChats(worldId) {
+            await ensureModulesLoaded();
+            if (worldStorage?.listChatHistories) {
+                return worldStorage.listChatHistories(rootPath, worldId);
+            }
+            return [];
+        },
+        async updateChatData(worldId, chatId, updates) {
+            await ensureModulesLoaded();
+            if (worldStorage?.updateChatData) {
+                return worldStorage.updateChatData(rootPath, worldId, chatId, updates);
+            }
+            return null;
+        },
+        async updateChatNameIfCurrent(worldId, chatId, expectedName, nextName) {
+            await ensureModulesLoaded();
+            if (worldStorage?.updateChatNameIfCurrent) {
+                return worldStorage.updateChatNameIfCurrent(rootPath, worldId, chatId, expectedName, nextName);
+            }
+            const current = await this.loadChatData(worldId, chatId);
+            if (!current || current.name !== expectedName) {
+                return false;
+            }
+            const updated = await this.updateChatData(worldId, chatId, { name: nextName });
+            return !!updated;
+        },
+        async saveWorldChat(worldId, chatId, chat) {
+            await ensureModulesLoaded();
+            if (worldStorage?.saveWorldChat) {
+                return worldStorage.saveWorldChat(rootPath, worldId, chatId, chat);
+            }
+        },
+        async loadWorldChat(worldId, chatId) {
+            await ensureModulesLoaded();
+            if (worldStorage?.loadWorldChat) {
+                return worldStorage.loadWorldChat(rootPath, worldId, chatId);
+            }
+            return null;
+        },
+        async loadWorldChatFull(worldId, chatId) {
+            await ensureModulesLoaded();
+            if (worldStorage?.loadWorldChatFull) {
+                return worldStorage.loadWorldChatFull(rootPath, worldId, chatId);
+            }
+            return null;
+        },
+        async restoreFromWorldChat(worldId, chat) {
+            await ensureModulesLoaded();
+            console.warn('[file-storage] World chat restoration not yet implemented for file storage');
+            return false;
+        },
+        async loadAgentWithRetry(worldId, agentId, options) {
+            await ensureModulesLoaded();
+            let retries = options?.retries || 3;
+            while (retries > 0) {
+                try {
+                    const agent = await this.loadAgent(worldId, agentId);
+                    if (agent)
+                        return agent;
+                }
+                catch (error) {
+                    console.warn(`[file-storage] Retry attempt ${retries} failed:`, error);
+                }
+                retries--;
+                if (retries > 0) {
+                    await new Promise(resolve => setTimeout(resolve, options?.delay || 100));
+                }
+            }
+            return null;
+        },
+        async agentExists(worldId, agentId) {
+            await ensureModulesLoaded();
+            try {
+                const agent = await this.loadAgent(worldId, agentId);
+                return !!agent;
+            }
+            catch {
+                return false;
+            }
+        },
+        async saveAgentMemory(worldId, agentId, memory) {
+            await ensureModulesLoaded();
+            // Use the direct saveAgentMemory function to avoid loading the entire agent
+            if (agentStorage?.saveAgentMemory) {
+                return agentStorage.saveAgentMemory(rootPath, worldId, agentId, memory);
+            }
+            // Fallback to load-modify-save if direct save not available
+            const agent = await this.loadAgent(worldId, agentId);
+            if (agent) {
+                agent.memory = memory;
+                await this.saveAgent(worldId, agent);
+            }
+        },
+        async archiveMemory(worldId, agentId, memory) {
+            await ensureModulesLoaded();
+            console.warn('[file-storage] Memory archiving not yet implemented for file storage');
+        },
+        async worldExists(worldId) {
+            await ensureModulesLoaded();
+            if (worldStorage?.worldExists) {
+                return worldStorage.worldExists(rootPath, worldId);
+            }
+            return false;
+        },
+        async deleteMemoryByChatId(worldId, chatId) {
+            await ensureModulesLoaded();
+            if (agentStorage?.deleteMemoryByChatId) {
+                return agentStorage.deleteMemoryByChatId(rootPath, worldId, chatId);
+            }
+            console.warn('[file-storage] Memory deletion by chat ID not available');
+            return 0;
+        }
+    };
+}
+// Instance caching for performance optimization
+const storageCache = new Map();
+// Flag to prevent duplicate log messages
+let hasLoggedStorageInit = false;
+/**
+ * Creates storage with environment-aware wrappers for browser/Node.js compatibility.
+ */
+export async function createStorageWithWrappers() {
+    if (isNodeEnvironment()) {
+        const storageInstance = await createStorageFromEnv();
+        return createStorageWrappers(storageInstance);
+    }
+    else {
+        // Use memory storage for non-Node environments (tests, browser)
+        const { createMemoryStorage } = await import('./memory-storage.js');
+        const memoryStorage = createMemoryStorage();
+        return createStorageWrappers(memoryStorage);
+    }
+}
+export async function createStorage(config) {
+    const cacheKey = `${config.type}-${config.rootPath}`;
+    if (storageCache.has(cacheKey)) {
+        return storageCache.get(cacheKey);
+    }
+    let storage;
+    if (config.type === 'memory') {
+        // Use memory storage - available in all environments
+        const { createMemoryStorage } = await import('./memory-storage.js');
+        storage = createMemoryStorage();
+        // Add memory event storage
+        const { createMemoryEventStorage } = await import('./eventStorage/index.js');
+        storage.eventStorage = createMemoryEventStorage();
+    }
+    else if (config.type === 'sqlite') {
+        if (!isNodeEnvironment()) {
+            throw new Error('SQLite storage not available in browser environment');
+        }
+        const sqliteConfig = {
+            database: config.sqlite?.database || path.join(config.rootPath, 'database.db'),
+            enableWAL: config.sqlite?.enableWAL !== false,
+            busyTimeout: config.sqlite?.busyTimeout || 30000,
+            cacheSize: config.sqlite?.cacheSize || -64000,
+            enableForeignKeys: config.sqlite?.enableForeignKeys !== false
+        };
+        // Use function-based SQLite API with schema initialization
+        const { createSQLiteStorageContext, saveWorld, loadWorld, deleteWorld, listWorlds, saveAgent, loadAgent, deleteAgent, listAgents, saveAgentsBatch, loadAgentsBatch, validateIntegrity, repairData, close, getDatabaseStats, initializeWithDefaults, saveChatData, loadChatData, deleteChatData, listChatHistories, updateChatData, updateChatNameIfCurrent, saveWorldChat, loadWorldChat, loadWorldChatFull, restoreFromWorldChat, archiveAgentMemory, deleteMemoryByChatId, getMemory, saveAgentMemory } = await import('./sqlite-storage.js');
+        const ctx = await createSQLiteStorageContext(sqliteConfig);
+        // Note: ensureInitialized is called within sqlite-storage functions, no need to call here
+        // Only initialize with defaults if this is a fresh database
+        try {
+            await initializeWithDefaults(ctx);
+        }
+        catch (error) {
+            // If initialization fails (e.g., default world already exists), continue anyway
+            console.warn('[storage-factory] Warning during default initialization:', error instanceof Error ? error.message : error);
+        }
+        storage = {
+            saveWorld: (worldData) => saveWorld(ctx, worldData),
+            loadWorld: (worldId) => loadWorld(ctx, worldId),
+            deleteWorld: (worldId) => deleteWorld(ctx, worldId),
+            listWorlds: () => listWorlds(ctx),
+            saveAgent: (worldId, agent) => saveAgent(ctx, worldId, agent),
+            loadAgent: (worldId, agentId) => loadAgent(ctx, worldId, agentId),
+            deleteAgent: (worldId, agentId) => deleteAgent(ctx, worldId, agentId),
+            listAgents: (worldId) => listAgents(ctx, worldId),
+            saveAgentsBatch: (worldId, agents) => saveAgentsBatch(ctx, worldId, agents),
+            loadAgentsBatch: (worldId, agentIds) => loadAgentsBatch(ctx, worldId, agentIds),
+            validateIntegrity: (worldId, agentId) => validateIntegrity(ctx, worldId, agentId),
+            repairData: (worldId, agentId) => repairData(ctx, worldId, agentId),
+            saveChatData: (worldId, chat) => saveChatData(ctx, worldId, chat),
+            loadChatData: (worldId, chatId) => loadChatData(ctx, worldId, chatId),
+            deleteChatData: (worldId, chatId) => deleteChatData(ctx, worldId, chatId),
+            listChats: (worldId) => listChatHistories(ctx, worldId),
+            updateChatData: (worldId, chatId, updates) => updateChatData(ctx, worldId, chatId, updates),
+            updateChatNameIfCurrent: (worldId, chatId, expectedName, nextName) => updateChatNameIfCurrent(ctx, worldId, chatId, expectedName, nextName),
+            saveWorldChat: (worldId, chatId, chat) => saveWorldChat(ctx, worldId, chatId, chat),
+            loadWorldChat: (worldId, chatId) => loadWorldChat(ctx, worldId, chatId),
+            loadWorldChatFull: (worldId, chatId) => loadWorldChatFull(ctx, worldId, chatId),
+            restoreFromWorldChat: async (worldId, chat) => {
+                return await restoreFromWorldChat(ctx, worldId, chat);
+            },
+            // Additional methods for consistency with StorageAPI
+            worldExists: async (worldId) => {
+                try {
+                    const world = await loadWorld(ctx, worldId);
+                    return !!world;
+                }
+                catch {
+                    return false;
+                }
+            },
+            loadAgentWithRetry: async (worldId, agentId, options) => {
+                let retries = options?.retries || 3;
+                while (retries > 0) {
+                    try {
+                        const agent = await loadAgent(ctx, worldId, agentId);
+                        if (agent)
+                            return agent;
+                    }
+                    catch (error) {
+                        console.warn(`[sqlite-storage] Retry attempt ${retries} failed:`, error);
+                    }
+                    retries--;
+                    if (retries > 0) {
+                        await new Promise(resolve => setTimeout(resolve, options?.delay || 100));
+                    }
+                }
+                return null;
+            },
+            agentExists: async (worldId, agentId) => {
+                try {
+                    const agent = await loadAgent(ctx, worldId, agentId);
+                    return !!agent;
+                }
+                catch {
+                    return false;
+                }
+            },
+            saveAgentMemory: async (worldId, agentId, memory) => {
+                await saveAgentMemory(ctx, worldId, agentId, memory);
+            },
+            archiveMemory: async (worldId, agentId, memory) => {
+                await archiveAgentMemory(ctx, worldId, agentId, memory);
+            },
+            deleteMemoryByChatId: async (worldId, chatId) => {
+                return await deleteMemoryByChatId(ctx, worldId, chatId);
+            },
+            getMemory: (worldId, chatId) => getMemory(ctx, worldId, chatId),
+            close: () => close(ctx),
+            getDatabaseStats: () => getDatabaseStats(ctx)
+        };
+        // Add SQLite event storage using same DB connection
+        const { createSQLiteEventStorage } = await import('./eventStorage/index.js');
+        storage.eventStorage = await createSQLiteEventStorage(ctx.db);
+    }
+    else {
+        storage = createFileStorageAdapter(config.rootPath);
+        // Add file-based event storage
+        const { createFileEventStorage } = await import('./eventStorage/index.js');
+        storage.eventStorage = createFileEventStorage({
+            baseDir: config.rootPath
+        });
+    }
+    storageCache.set(cacheKey, storage);
+    return storage;
+}
+export function getDefaultRootPath() {
+    let rootPath = process.env.AGENT_WORLD_DATA_PATH;
+    if (!rootPath) {
+        // Default to ~/agent-world if not defined
+        const homeDir = process.env.HOME || process.env.USERPROFILE || '';
+        rootPath = homeDir ? path.join(homeDir, 'agent-world') : './agent-world';
+    }
+    // If AGENT_WORLD_DATA_PATH is absolute, use it as-is
+    // If relative, resolve relative to current working directory
+    if (path.isAbsolute(rootPath)) {
+        return rootPath;
+    }
+    else {
+        // For relative paths, don't use resolve if it's already in the correct format
+        if (rootPath === './agent-world') {
+            return './agent-world';
+        }
+        return path.resolve(process.cwd(), rootPath);
+    }
+}
+export async function createStorageFromEnv() {
+    const type = process.env.AGENT_WORLD_STORAGE_TYPE || 'sqlite';
+    const rootPath = getDefaultRootPath();
+    // Use a special cache key for environment-based storage
+    const envCacheKey = `env-${type}-${rootPath}`;
+    if (storageCache.has(envCacheKey)) {
+        return storageCache.get(envCacheKey);
+    }
+    // Ensure directory exists (except for memory storage)
+    if (isNodeEnvironment() && rootPath && typeof fs.existsSync === 'function' && !fs.existsSync(rootPath) && type !== 'memory') {
+        if (typeof fs.mkdirSync === 'function') {
+            fs.mkdirSync(rootPath, { recursive: true });
+        }
+    }
+    const config = {
+        type,
+        rootPath,
+        sqlite: type === 'sqlite'
+            ? {
+                database: process.env.AGENT_WORLD_SQLITE_DATABASE || path.join(rootPath, 'database.db'),
+                enableWAL: process.env.AGENT_WORLD_SQLITE_WAL !== 'false',
+                busyTimeout: parseInt(process.env.AGENT_WORLD_SQLITE_TIMEOUT || '30000'),
+                cacheSize: parseInt(process.env.AGENT_WORLD_SQLITE_CACHE || '-64000'),
+                enableForeignKeys: process.env.AGENT_WORLD_SQLITE_FK !== 'false'
+            }
+            : undefined
+    };
+    // Only log on first initialization to avoid duplicate logs
+    if (!hasLoggedStorageInit) {
+        logger.info('Storage initialized', {
+            path: config.rootPath,
+            type: config.type
+        });
+        hasLoggedStorageInit = true;
+    }
+    const storage = await createStorage(config);
+    // Cache with the special environment key
+    storageCache.set(envCacheKey, storage);
+    return storage;
+}
+//# sourceMappingURL=storage-factory.js.map