@olane/o-lane 0.7.18 → 0.7.20

package/dist/src/storage/prompt-storage-provider.tool.js

@@ -1,320 +0,0 @@
-import { StorageProviderTool } from '@olane/o-storage';
-import { oAddress } from '@olane/o-core';
-import { PROMPT_STORAGE_METHODS } from './methods/prompt-storage.methods.js';
-/**
- * Prompt-specific storage provider that isolates data per prompt/conversation
- * Extends StorageProviderTool to provide namespace isolation by promptId
- *
- * Features:
- * - Isolated storage namespaces per promptId
- * - Standard CRUD operations (put, get, delete, has)
- * - Prompt management (list, clear, stats)
- * - Optional TTL-based cleanup for inactive prompts
- * - Memory-efficient nested Map structure
- */
-export class PromptStorageProvider extends StorageProviderTool {
-    constructor(config) {
-        const finalConfig = {
-            ...config,
-            address: config.address || new oAddress('o://prompt-storage'),
-            methods: PROMPT_STORAGE_METHODS,
-            description: 'Prompt-specific storage provider with isolated namespaces per conversation',
-        };
-        super(finalConfig);
-        this.config = config;
-        this.config = finalConfig;
-        this.storage = new Map();
-        this.metadata = new Map();
-    }
-    /**
-     * Initialize background cleanup task if TTL is configured
-     */
-    async hookStartFinished() {
-        if (this.config.promptTTL) {
-            const interval = this.config.cleanupInterval || 60000; // Default 1 minute
-            this.cleanupTimer = setInterval(() => {
-                this.cleanupExpiredPrompts();
-            }, interval);
-            this.logger.info('Prompt storage cleanup enabled', {
-                ttl: this.config.promptTTL,
-                interval,
-            });
-        }
-        await super.hookStartFinished();
-    }
-    /**
-     * Store data in a prompt-specific namespace
-     * ✅ Throws errors for validation failures
-     * ✅ Returns raw data (base class wraps it)
-     */
-    async _tool_put(request) {
-        const { promptId, key, value } = request.params;
-        // Validate required parameters
-        if (!promptId || typeof promptId !== 'string') {
-            throw new Error('promptId is required and must be a string');
-        }
-        if (!key || typeof key !== 'string') {
-            throw new Error('key is required and must be a string');
-        }
-        if (value === undefined || value === null) {
-            throw new Error('value is required');
-        }
-        // Ensure prompt namespace exists
-        if (!this.storage.has(promptId)) {
-            this.storage.set(promptId, new Map());
-            this.metadata.set(promptId, {
-                createdAt: Date.now(),
-                lastAccessed: Date.now(),
-            });
-        }
-        // Store value and update metadata
-        const promptStorage = this.storage.get(promptId);
-        promptStorage.set(key, String(value));
-        this.updateLastAccessed(promptId);
-        // Check max prompts limit
-        if (this.config.maxPrompts && this.storage.size > this.config.maxPrompts) {
-            this.evictOldestPrompt();
-        }
-        return {
-            success: true,
-        };
-    }
-    /**
-     * Retrieve data from a prompt-specific namespace
-     * ✅ Throws errors for validation failures
-     * ✅ Returns raw data with null for missing keys
-     */
-    async _tool_get(request) {
-        const { promptId, key } = request.params;
-        // Validate required parameters
-        if (!promptId || typeof promptId !== 'string') {
-            throw new Error('promptId is required and must be a string');
-        }
-        if (!key || typeof key !== 'string') {
-            throw new Error('key is required and must be a string');
-        }
-        // Check if prompt exists
-        const promptStorage = this.storage.get(promptId);
-        if (!promptStorage) {
-            return {
-                value: null,
-            };
-        }
-        // Get value and update metadata
-        const value = promptStorage.get(key);
-        if (value !== undefined) {
-            this.updateLastAccessed(promptId);
-        }
-        return {
-            value: value ?? null,
-        };
-    }
-    /**
-     * Delete a specific key from a prompt namespace
-     * ✅ Throws errors for validation failures
-     * ✅ Returns raw data
-     */
-    async _tool_delete(request) {
-        const { promptId, key } = request.params;
-        // Validate required parameters
-        if (!promptId || typeof promptId !== 'string') {
-            throw new Error('promptId is required and must be a string');
-        }
-        if (!key || typeof key !== 'string') {
-            throw new Error('key is required and must be a string');
-        }
-        // Get prompt storage
-        const promptStorage = this.storage.get(promptId);
-        if (!promptStorage) {
-            // Not an error - deleting non-existent key is idempotent
-            return {
-                success: true,
-            };
-        }
-        // Delete key and update metadata
-        promptStorage.delete(key);
-        this.updateLastAccessed(promptId);
-        // Clean up empty prompt namespace
-        if (promptStorage.size === 0) {
-            this.storage.delete(promptId);
-            this.metadata.delete(promptId);
-        }
-        return {
-            success: true,
-        };
-    }
-    /**
-     * Check if a key exists in a prompt namespace
-     * ✅ Throws errors for validation failures
-     * ✅ Returns raw data
-     */
-    async _tool_has(request) {
-        const { promptId, key } = request.params;
-        // Validate required parameters
-        if (!promptId || typeof promptId !== 'string') {
-            throw new Error('promptId is required and must be a string');
-        }
-        if (!key || typeof key !== 'string') {
-            throw new Error('key is required and must be a string');
-        }
-        // Check existence
-        const promptStorage = this.storage.get(promptId);
-        const exists = promptStorage ? promptStorage.has(key) : false;
-        if (exists) {
-            this.updateLastAccessed(promptId);
-        }
-        return {
-            success: exists,
-        };
-    }
-    /**
-     * List all prompt IDs with active storage
-     */
-    async _tool_list_prompts(_request) {
-        const promptIds = Array.from(this.storage.keys());
-        return {
-            promptIds,
-            count: promptIds.length,
-        };
-    }
-    /**
-     * Clear all data for a specific prompt namespace
-     */
-    async _tool_clear_prompt(request) {
-        const { promptId } = request.params;
-        // Validate required parameter
-        if (!promptId || typeof promptId !== 'string') {
-            throw new Error('promptId is required and must be a string');
-        }
-        const promptStorage = this.storage.get(promptId);
-        if (!promptStorage) {
-            return {
-                success: true,
-                keysDeleted: 0,
-            };
-        }
-        const keysDeleted = promptStorage.size;
-        // Clear storage and metadata
-        this.storage.delete(promptId);
-        this.metadata.delete(promptId);
-        return {
-            success: true,
-            keysDeleted,
-        };
-    }
-    /**
-     * Get all keys stored in a specific prompt namespace
-     */
-    async _tool_get_prompt_keys(request) {
-        const { promptId } = request.params;
-        // Validate required parameter
-        if (!promptId || typeof promptId !== 'string') {
-            throw new Error('promptId is required and must be a string');
-        }
-        const promptStorage = this.storage.get(promptId);
-        if (!promptStorage) {
-            return {
-                keys: [],
-                count: 0,
-            };
-        }
-        const keys = Array.from(promptStorage.keys());
-        this.updateLastAccessed(promptId);
-        return {
-            keys,
-            count: keys.length,
-        };
-    }
-    /**
-     * Get statistics for a specific prompt namespace
-     */
-    async _tool_get_prompt_stats(request) {
-        const { promptId } = request.params;
-        // Validate required parameter
-        if (!promptId || typeof promptId !== 'string') {
-            throw new Error('promptId is required and must be a string');
-        }
-        const promptStorage = this.storage.get(promptId);
-        const meta = this.metadata.get(promptId);
-        if (!promptStorage || !meta) {
-            return {
-                promptId,
-                keyCount: 0,
-                lastAccessed: 0,
-                exists: false,
-            };
-        }
-        this.updateLastAccessed(promptId);
-        return {
-            promptId,
-            keyCount: promptStorage.size,
-            lastAccessed: meta.lastAccessed,
-            exists: true,
-            createdAt: meta.createdAt,
-        };
-    }
-    /**
-     * Cleanup resources on stop
-     */
-    async stop() {
-        if (this.cleanupTimer) {
-            clearInterval(this.cleanupTimer);
-            this.cleanupTimer = undefined;
-        }
-        await super.stop();
-    }
-    /**
-     * Update last accessed timestamp for a prompt
-     */
-    updateLastAccessed(promptId) {
-        const meta = this.metadata.get(promptId);
-        if (meta) {
-            meta.lastAccessed = Date.now();
-        }
-    }
-    /**
-     * Clean up prompts that haven't been accessed within TTL
-     */
-    cleanupExpiredPrompts() {
-        if (!this.config.promptTTL)
-            return;
-        const now = Date.now();
-        const expiredPrompts = [];
-        for (const [promptId, meta] of this.metadata.entries()) {
-            if (now - meta.lastAccessed > this.config.promptTTL) {
-                expiredPrompts.push(promptId);
-            }
-        }
-        if (expiredPrompts.length > 0) {
-            for (const promptId of expiredPrompts) {
-                this.storage.delete(promptId);
-                this.metadata.delete(promptId);
-            }
-            this.logger.info('Cleaned up expired prompts', {
-                count: expiredPrompts.length,
-                promptIds: expiredPrompts,
-            });
-        }
-    }
-    /**
-     * Evict the oldest prompt when max limit is reached
-     */
-    evictOldestPrompt() {
-        let oldestPromptId;
-        let oldestTime = Infinity;
-        for (const [promptId, meta] of this.metadata.entries()) {
-            if (meta.lastAccessed < oldestTime) {
-                oldestTime = meta.lastAccessed;
-                oldestPromptId = promptId;
-            }
-        }
-        if (oldestPromptId) {
-            this.storage.delete(oldestPromptId);
-            this.metadata.delete(oldestPromptId);
-            this.logger.info('Evicted oldest prompt', {
-                promptId: oldestPromptId,
-                lastAccessed: oldestTime,
-            });
-        }
-    }
-}

package/dist/test/prompt-seeder.spec.d.ts

@@ -1,2 +0,0 @@
-import 'dotenv/config';
-//# sourceMappingURL=prompt-seeder.spec.d.ts.map

package/dist/test/prompt-seeder.spec.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"prompt-seeder.spec.d.ts","sourceRoot":"","sources":["../../test/prompt-seeder.spec.ts"],"names":[],"mappings":"AAAA,OAAO,eAAe,CAAC"}

package/dist/test/prompt-seeder.spec.js

@@ -1,256 +0,0 @@
-import 'dotenv/config';
-import { describe, it, before, after } from 'mocha';
-import { expect } from 'chai';
-import { PromptStorageProvider } from '../src/storage/prompt-storage-provider.tool.js';
-import { PromptSeeder } from '../src/storage/prompt-seeder.js';
-import { PromptLoader } from '../src/storage/prompt-loader.js';
-import { PROMPT_KEYS, PROMPT_IDS, } from '../src/storage/prompt-schema.js';
-import { AGENT_PROMPT } from '../src/prompts/agent.prompt.js';
-import { CONFIGURE_INSTRUCTIONS } from '../src/prompts/configure.prompt.js';
-import { TestEnvironment } from '@olane/o-node/test/helpers';
-import { assertSuccess, assertDefined } from '@olane/o-test';
-describe('Prompt Seeding and Loading', () => {
-    const env = new TestEnvironment();
-    let storage;
-    let seeder;
-    let loader;
-    before(async () => {
-        // @ts-ignore
-        storage = await env.createNode(PromptStorageProvider, {});
-        seeder = new PromptSeeder(storage);
-        loader = new PromptLoader(storage);
-    });
-    after(async () => {
-        await env.cleanup();
-    });
-    describe('PromptSeeder', () => {
-        it('should check if prompts are not seeded initially', async () => {
-            const isSeeded = await seeder.isSeeded();
-            expect(isSeeded).to.equal(false);
-        });
-        it('should seed all prompts successfully', async () => {
-            await seeder.seedAll();
-            // Verify all prompts are stored
-            const baseTemplateResponse = await storage.use(storage.address, {
-                method: 'has',
-                params: {
-                    promptId: PROMPT_IDS.AGENT,
-                    key: PROMPT_KEYS.BASE_TEMPLATE,
-                },
-            });
-            assertSuccess(baseTemplateResponse);
-            expect(baseTemplateResponse.result?.data?.exists).to.equal(true);
-            const cycleResponse = await storage.use(storage.address, {
-                method: 'has',
-                params: {
-                    promptId: PROMPT_IDS.AGENT,
-                    key: PROMPT_KEYS.CYCLE_INSTRUCTIONS,
-                },
-            });
-            assertSuccess(cycleResponse);
-            expect(cycleResponse.result?.data?.exists).to.equal(true);
-            const outputResponse = await storage.use(storage.address, {
-                method: 'has',
-                params: {
-                    promptId: PROMPT_IDS.AGENT,
-                    key: PROMPT_KEYS.OUTPUT_INSTRUCTIONS,
-                },
-            });
-            assertSuccess(outputResponse);
-            expect(outputResponse.result?.data?.exists).to.equal(true);
-            const configureResponse = await storage.use(storage.address, {
-                method: 'has',
-                params: {
-                    promptId: PROMPT_IDS.AGENT,
-                    key: PROMPT_KEYS.CONFIGURE_INSTRUCTIONS,
-                },
-            });
-            assertSuccess(configureResponse);
-            expect(configureResponse.result?.data?.exists).to.equal(true);
-        });
-        it('should confirm prompts are seeded after seeding', async () => {
-            const isSeeded = await seeder.isSeeded();
-            expect(isSeeded).to.equal(true);
-        });
-        it('should store prompts with correct metadata', async () => {
-            const response = await storage.use(storage.address, {
-                method: 'get',
-                params: {
-                    promptId: PROMPT_IDS.AGENT,
-                    key: PROMPT_KEYS.BASE_TEMPLATE,
-                },
-            });
-            assertSuccess(response);
-            const template = response.result?.data?.value;
-            assertDefined(template, 'template');
-            expect(template.content).to.exist;
-            expect(template.metadata).to.exist;
-            expect(template.metadata.version).to.equal('1.0.0');
-            expect(template.metadata.source).to.equal('custom.prompt.ts');
-        });
-        it('should store base template with placeholders', async () => {
-            const response = await storage.use(storage.address, {
-                method: 'get',
-                params: {
-                    promptId: PROMPT_IDS.AGENT,
-                    key: PROMPT_KEYS.BASE_TEMPLATE,
-                },
-            });
-            assertSuccess(response);
-            const template = response.result?.data?.value;
-            assertDefined(template, 'template');
-            expect(template.content).to.include('{{intent}}');
-            expect(template.content).to.include('{{context}}');
-            expect(template.content).to.include('{{agentHistory}}');
-            expect(template.content).to.include('{{cycleInstructions}}');
-            expect(template.content).to.include('{{outputInstructions}}');
-            expect(template.content).to.include('{{extraInstructions}}');
-        });
-        it('should store cycle instructions with step details', async () => {
-            const response = await storage.use(storage.address, {
-                method: 'get',
-                params: {
-                    promptId: PROMPT_IDS.AGENT,
-                    key: PROMPT_KEYS.CYCLE_INSTRUCTIONS,
-                },
-            });
-            assertSuccess(response);
-            const template = response.result?.data?.value;
-            assertDefined(template, 'template');
-            expect(template.content).to.include('Step 1 - Evaluate the intent');
-            expect(template.content).to.include('Step 2 - Search for tools and context');
-            expect(template.content).to.include('Step 3 - Filter Search Results');
-            expect(template.content).to.include('Step 4 - Configure the target tool address use');
-            expect(template.content).to.include('Step 5 - Use target tool address');
-            expect(template.content).to.include('Step 6 - Review the tool use results');
-        });
-        it('should store output instructions with return types', async () => {
-            const response = await storage.use(storage.address, {
-                method: 'get',
-                params: {
-                    promptId: PROMPT_IDS.AGENT,
-                    key: PROMPT_KEYS.OUTPUT_INSTRUCTIONS,
-                },
-            });
-            assertSuccess(response);
-            const template = response.result?.data?.value;
-            assertDefined(template, 'template');
-            expect(template.content).to.include('Complex Intent Results');
-            expect(template.content).to.include('Configure Response');
-            expect(template.content).to.include('Search Response');
-            expect(template.content).to.include('Stop Response');
-            expect(template.content).to.include('Error Response');
-            expect(template.content).to.include('Use Tool Response');
-        });
-        it('should clear all prompts', async () => {
-            await seeder.clearAll();
-            const isSeeded = await seeder.isSeeded();
-            expect(isSeeded).to.equal(false);
-        });
-    });
-    describe('PromptLoader', () => {
-        before(async () => {
-            // Ensure prompts are seeded for loader tests
-            await seeder.seedAll();
-        });
-        it('should load configure instructions from storage', async () => {
-            const instructions = await loader.loadConfigureInstructions();
-            expect(instructions).to.exist;
-            expect(instructions).to.include('Configure Request Instructions');
-            expect(instructions).to.include('Step 1 - Validate the intent');
-        });
-        it('should generate agent prompt from storage', async () => {
-            const prompt = await loader.generateAgentPrompt('test intent', 'test context', 'test history', 'test extra');
-            expect(prompt).to.exist;
-            expect(prompt).to.include('test intent');
-            expect(prompt).to.include('test context');
-            expect(prompt).to.include('test history');
-            expect(prompt).to.include('test extra');
-            expect(prompt).to.include('Step 1 - Evaluate the intent');
-            expect(prompt).to.include('Stop Response');
-        });
-        it('should generate prompt identical to hardcoded version', async () => {
-            const intent = 'Get user information';
-            const context = 'User ID: 123';
-            const history = 'Previous cycle: searched for user';
-            const extra = 'Be concise';
-            const storagePrompt = await loader.generateAgentPrompt(intent, context, history, extra);
-            const hardcodedPrompt = AGENT_PROMPT(intent, context, history, extra);
-            expect(storagePrompt).to.equal(hardcodedPrompt);
-        });
-        it('should cache loaded templates', async () => {
-            // Clear cache first
-            loader.clearCache();
-            // First load - should hit storage
-            const prompt1 = await loader.generateAgentPrompt('test', 'test', 'test', 'test');
-            // Second load - should use cache
-            const prompt2 = await loader.generateAgentPrompt('test', 'test', 'test', 'test');
-            expect(prompt1).to.equal(prompt2);
-        });
-        it('should fallback to hardcoded prompts when storage unavailable', async () => {
-            const loaderWithoutStorage = new PromptLoader();
-            const prompt = await loaderWithoutStorage.generateAgentPrompt('test intent', 'test context', 'test history', 'test extra');
-            expect(prompt).to.exist;
-            expect(prompt).to.include('test intent');
-            expect(prompt).to.include('Step 1 - Evaluate the intent');
-        });
-        it('should fallback to hardcoded configure instructions when storage unavailable', async () => {
-            const loaderWithoutStorage = new PromptLoader();
-            const instructions = await loaderWithoutStorage.loadConfigureInstructions();
-            expect(instructions).to.equal(CONFIGURE_INSTRUCTIONS);
-        });
-        it('should allow disabling storage usage', async () => {
-            loader.setUseStorage(false);
-            const prompt = await loader.generateAgentPrompt('test', 'test', 'test', 'test');
-            expect(prompt).to.exist;
-            // Re-enable for other tests
-            loader.setUseStorage(true);
-        });
-    });
-    describe('Integration', () => {
-        it('should handle complete seed-load-clear cycle', async () => {
-            // Clear first
-            await seeder.clearAll();
-            expect(await seeder.isSeeded()).to.equal(false);
-            // Seed
-            await seeder.seedAll();
-            expect(await seeder.isSeeded()).to.equal(true);
-            // Load and verify
-            loader.clearCache();
-            const prompt = await loader.generateAgentPrompt('test', 'test', 'test', 'test');
-            expect(prompt).to.include('test');
-            const instructions = await loader.loadConfigureInstructions();
-            expect(instructions).to.include('Configure Request Instructions');
-            // Clear again
-            await seeder.clearAll();
-            expect(await seeder.isSeeded()).to.equal(false);
-        });
-        it('should list all seeded prompts', async () => {
-            await seeder.seedAll();
-            const response = await storage.use(storage.address, {
-                method: 'get_prompt_keys',
-                params: {
-                    promptId: PROMPT_IDS.AGENT,
-                },
-            });
-            assertSuccess(response);
-            expect(response.result?.data?.keys).to.include(PROMPT_KEYS.BASE_TEMPLATE);
-            expect(response.result?.data?.keys).to.include(PROMPT_KEYS.CYCLE_INSTRUCTIONS);
-            expect(response.result?.data?.keys).to.include(PROMPT_KEYS.OUTPUT_INSTRUCTIONS);
-            expect(response.result?.data?.keys).to.include(PROMPT_KEYS.CONFIGURE_INSTRUCTIONS);
-            expect(response.result?.data?.count).to.equal(4);
-        });
-        it('should get stats for seeded prompts', async () => {
-            const response = await storage.use(storage.address, {
-                method: 'get_prompt_stats',
-                params: {
-                    promptId: PROMPT_IDS.AGENT,
-                },
-            });
-            assertSuccess(response);
-            expect(response.result?.data?.exists).to.equal(true);
-            expect(response.result?.data?.keyCount).to.equal(4);
-            expect(response.result?.data?.promptId).to.equal(PROMPT_IDS.AGENT);
-        });
-    });
-});

package/dist/test/prompt-storage-provider.spec.d.ts

@@ -1,2 +0,0 @@
-import 'dotenv/config';
-//# sourceMappingURL=prompt-storage-provider.spec.d.ts.map

package/dist/test/prompt-storage-provider.spec.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"prompt-storage-provider.spec.d.ts","sourceRoot":"","sources":["../../test/prompt-storage-provider.spec.ts"],"names":[],"mappings":"AAAA,OAAO,eAAe,CAAC"}