@olane/o-lane 0.7.12-alpha.76 → 0.7.12

package/dist/test/prompt-storage-provider.spec.js

@@ -0,0 +1,456 @@
+import 'dotenv/config';
+import { expect } from 'chai';
+import { PromptStorageProvider } from '../src/storage/prompt-storage-provider.tool.js';
+import { TestEnvironment, SimpleNodeBuilder, assertRunning, assertStopped, assertSuccess, assertError, } from '@olane/o-test';
+import { oNodeAddress } from '@olane/o-node';
+describe('PromptStorageProvider', () => {
+    const env = new TestEnvironment();
+    let storage;
+    beforeEach(async () => {
+        storage = await new SimpleNodeBuilder(PromptStorageProvider)
+            .withAddress(new oNodeAddress('o://prompt-storage-test'))
+            .build(env);
+    });
+    afterEach(async () => {
+        await env.cleanup();
+    });
+    describe('Lifecycle', () => {
+        it('should initialize successfully', () => {
+            expect(storage).to.exist;
+            assertRunning(storage);
+            expect(storage.address.toString()).to.equal('o://prompt-storage-test');
+        });
+        it('should stop successfully', async () => {
+            await storage.stop();
+            assertStopped(storage);
+        });
+    });
+    describe('Basic CRUD Operations', () => {
+        it('should store and retrieve data', async () => {
+            const putResult = await storage.use(storage.address, {
+                method: 'put',
+                params: {
+                    promptId: 'test-prompt-1',
+                    key: 'user_name',
+                    value: 'Alice',
+                },
+            });
+            assertSuccess(putResult);
+            const response = await storage.use(storage.address, {
+                method: 'get',
+                params: {
+                    promptId: 'test-prompt-1',
+                    key: 'user_name',
+                },
+            });
+            assertSuccess(response);
+            expect(response.result.data.value).to.equal('Alice');
+        });
+        it('should return null for non-existent key', async () => {
+            const result = await storage.use(storage.address, {
+                method: 'get',
+                params: {
+                    promptId: 'test-prompt-1',
+                    key: 'nonexistent',
+                },
+            });
+            assertSuccess(result);
+            expect(result.result.data.value).to.be.null;
+        });
+        it('should return null for non-existent prompt', async () => {
+            const result = await storage.use(storage.address, {
+                method: 'get',
+                params: {
+                    promptId: 'nonexistent-prompt',
+                    key: 'some_key',
+                },
+            });
+            assertSuccess(result);
+            expect(result.result.data.value).to.be.null;
+        });
+        it('should delete data', async () => {
+            // Store data first
+            await storage.use(storage.address, {
+                method: 'put',
+                params: {
+                    promptId: 'test-prompt-1',
+                    key: 'temp_data',
+                    value: 'temporary',
+                },
+            });
+            // Verify it exists
+            const beforeDelete = await storage.use(storage.address, {
+                method: 'get',
+                params: {
+                    promptId: 'test-prompt-1',
+                    key: 'temp_data',
+                },
+            });
+            assertSuccess(beforeDelete);
+            expect(beforeDelete.result.data.value).to.equal('temporary');
+            // Delete it
+            const deleteResult = await storage.use(storage.address, {
+                method: 'delete',
+                params: {
+                    promptId: 'test-prompt-1',
+                    key: 'temp_data',
+                },
+            });
+            assertSuccess(deleteResult);
+            // Verify it's gone
+            const afterDelete = await storage.use(storage.address, {
+                method: 'get',
+                params: {
+                    promptId: 'test-prompt-1',
+                    key: 'temp_data',
+                },
+            });
+            assertSuccess(afterDelete);
+            expect(afterDelete.result.data.value).to.be.null;
+        });
+        it('should check key existence with has', async () => {
+            // Check non-existent key
+            const beforePut = await storage.use(storage.address, {
+                method: 'has',
+                params: {
+                    promptId: 'test-prompt-1',
+                    key: 'test_key',
+                },
+            });
+            assertSuccess(beforePut);
+            expect(beforePut.result.data.success).to.be.false;
+            // Store data
+            await storage.use(storage.address, {
+                method: 'put',
+                params: {
+                    promptId: 'test-prompt-1',
+                    key: 'test_key',
+                    value: 'test_value',
+                },
+            });
+            // Check existing key
+            const afterPut = await storage.use(storage.address, {
+                method: 'has',
+                params: {
+                    promptId: 'test-prompt-1',
+                    key: 'test_key',
+                },
+            });
+            assertSuccess(afterPut);
+            expect(afterPut.result.data.success).to.be.true;
+        });
+    });
+    describe('Prompt Isolation', () => {
+        it('should isolate data between different prompts', async () => {
+            // Store same key in different prompts
+            await storage.use(storage.address, {
+                method: 'put',
+                params: {
+                    promptId: 'prompt-1',
+                    key: 'shared_key',
+                    value: 'value-1',
+                },
+            });
+            await storage.use(storage.address, {
+                method: 'put',
+                params: {
+                    promptId: 'prompt-2',
+                    key: 'shared_key',
+                    value: 'value-2',
+                },
+            });
+            // Verify each prompt has its own value
+            const result1 = await storage.use(storage.address, {
+                method: 'get',
+                params: {
+                    promptId: 'prompt-1',
+                    key: 'shared_key',
+                },
+            });
+            expect(result1.result.data.value).to.equal('value-1');
+            const result2 = await storage.use(storage.address, {
+                method: 'get',
+                params: {
+                    promptId: 'prompt-2',
+                    key: 'shared_key',
+                },
+            });
+            expect(result2.result.data.value).to.equal('value-2');
+        });
+        it('should not leak data between prompts on delete', async () => {
+            // Store in both prompts
+            await storage.use(storage.address, {
+                method: 'put',
+                params: { promptId: 'prompt-1', key: 'key', value: 'value-1' },
+            });
+            await storage.use(storage.address, {
+                method: 'put',
+                params: { promptId: 'prompt-2', key: 'key', value: 'value-2' },
+            });
+            // Delete from prompt-1
+            await storage.use(storage.address, {
+                method: 'delete',
+                params: { promptId: 'prompt-1', key: 'key' },
+            });
+            // Verify prompt-1 is deleted
+            const result1 = await storage.use(storage.address, {
+                method: 'get',
+                params: { promptId: 'prompt-1', key: 'key' },
+            });
+            expect(result1.result.data.value).to.be.null;
+            // Verify prompt-2 is unaffected
+            const result2 = await storage.use(storage.address, {
+                method: 'get',
+                params: { promptId: 'prompt-2', key: 'key' },
+            });
+            expect(result2.result.data.value).to.equal('value-2');
+        });
+    });
+    describe('Prompt Management', () => {
+        it('should list all prompts', async () => {
+            // Store data in multiple prompts
+            await storage.use(storage.address, {
+                method: 'put',
+                params: { promptId: 'prompt-1', key: 'key1', value: 'value1' },
+            });
+            await storage.use(storage.address, {
+                method: 'put',
+                params: { promptId: 'prompt-2', key: 'key2', value: 'value2' },
+            });
+            await storage.use(storage.address, {
+                method: 'put',
+                params: { promptId: 'prompt-3', key: 'key3', value: 'value3' },
+            });
+            // List prompts
+            const result = await storage.use(storage.address, {
+                method: 'list_prompts',
+                params: {},
+            });
+            assertSuccess(result);
+            expect(result.result.data.count).to.equal(3);
+            expect(result.result.data.promptIds).to.have.members([
+                'prompt-1',
+                'prompt-2',
+                'prompt-3',
+            ]);
+        });
+        it('should clear a specific prompt', async () => {
+            // Store multiple keys in a prompt
+            await storage.use(storage.address, {
+                method: 'put',
+                params: { promptId: 'prompt-1', key: 'key1', value: 'value1' },
+            });
+            await storage.use(storage.address, {
+                method: 'put',
+                params: { promptId: 'prompt-1', key: 'key2', value: 'value2' },
+            });
+            await storage.use(storage.address, {
+                method: 'put',
+                params: { promptId: 'prompt-1', key: 'key3', value: 'value3' },
+            });
+            // Clear the prompt
+            const clearResult = await storage.use(storage.address, {
+                method: 'clear_prompt',
+                params: { promptId: 'prompt-1' },
+            });
+            assertSuccess(clearResult);
+            expect(clearResult.result.data.success).to.be.true;
+            expect(clearResult.result.data.keysDeleted).to.equal(3);
+            // Verify all keys are gone
+            const getResult = await storage.use(storage.address, {
+                method: 'get',
+                params: { promptId: 'prompt-1', key: 'key1' },
+            });
+            assertSuccess(getResult);
+            expect(getResult.result.data.value).to.be.null;
+        });
+        it('should get keys for a specific prompt', async () => {
+            // Store multiple keys
+            await storage.use(storage.address, {
+                method: 'put',
+                params: { promptId: 'prompt-1', key: 'name', value: 'Alice' },
+            });
+            await storage.use(storage.address, {
+                method: 'put',
+                params: { promptId: 'prompt-1', key: 'email', value: 'alice@example.com' },
+            });
+            await storage.use(storage.address, {
+                method: 'put',
+                params: { promptId: 'prompt-1', key: 'role', value: 'admin' },
+            });
+            // Get keys
+            const result = await storage.use(storage.address, {
+                method: 'get_prompt_keys',
+                params: { promptId: 'prompt-1' },
+            });
+            assertSuccess(result);
+            expect(result.result.data.count).to.equal(3);
+            expect(result.result.data.keys).to.have.members(['name', 'email', 'role']);
+        });
+        it('should get stats for a specific prompt', async () => {
+            // Store some data
+            await storage.use(storage.address, {
+                method: 'put',
+                params: { promptId: 'prompt-1', key: 'key1', value: 'value1' },
+            });
+            await storage.use(storage.address, {
+                method: 'put',
+                params: { promptId: 'prompt-1', key: 'key2', value: 'value2' },
+            });
+            // Get stats
+            const result = await storage.use(storage.address, {
+                method: 'get_prompt_stats',
+                params: { promptId: 'prompt-1' },
+            });
+            assertSuccess(result);
+            expect(result.result.data.promptId).to.equal('prompt-1');
+            expect(result.result.data.keyCount).to.equal(2);
+            expect(result.result.data.exists).to.be.true;
+            expect(result.result.data.lastAccessed).to.be.a('number');
+            expect(result.result.data.createdAt).to.be.a('number');
+        });
+        it('should return empty stats for non-existent prompt', async () => {
+            const result = await storage.use(storage.address, {
+                method: 'get_prompt_stats',
+                params: { promptId: 'nonexistent' },
+            });
+            assertSuccess(result);
+            expect(result.result.data.exists).to.be.false;
+            expect(result.result.data.keyCount).to.equal(0);
+        });
+    });
+    describe('Validation', () => {
+        it('should throw error for missing promptId in put', async () => {
+            const response = await storage.use(storage.address, {
+                method: 'put',
+                params: { key: 'key', value: 'value' },
+            });
+            assertError(response, 'Missing required parameters');
+        });
+        it('should throw error for missing key in put', async () => {
+            const result = await storage.use(storage.address, {
+                method: 'put',
+                params: { promptId: 'prompt-1', value: 'value' },
+            });
+            assertError(result, 'Missing required parameters');
+        });
+        it('should throw error for missing value in put', async () => {
+            const result = await storage.use(storage.address, {
+                method: 'put',
+                params: { promptId: 'prompt-1', key: 'key' },
+            });
+            assertError(result, 'Missing required parameters');
+        });
+        it('should throw error for invalid promptId type', async () => {
+            const result = await storage.use(storage.address, {
+                method: 'get',
+                params: { promptId: 123, key: 'key' },
+            });
+            assertError(result, 'promptId is required and must be a string');
+        });
+    });
+    describe('Edge Cases', () => {
+        it('should handle empty prompt list', async () => {
+            const result = await storage.use(storage.address, {
+                method: 'list_prompts',
+                params: {},
+            });
+            assertSuccess(result);
+            expect(result.result.data.count).to.equal(0);
+            expect(result.result.data.promptIds).to.be.an('array').that.is.empty;
+        });
+        it('should handle clearing non-existent prompt', async () => {
+            const result = await storage.use(storage.address, {
+                method: 'clear_prompt',
+                params: { promptId: 'nonexistent' },
+            });
+            assertSuccess(result);
+            expect(result.result.data.keysDeleted).to.equal(0);
+        });
+        it('should handle deleting non-existent key', async () => {
+            const result = await storage.use(storage.address, {
+                method: 'delete',
+                params: { promptId: 'prompt-1', key: 'nonexistent' },
+            });
+            assertSuccess(result);
+        });
+        it('should handle overwriting existing value', async () => {
+            // Store initial value
+            await storage.use(storage.address, {
+                method: 'put',
+                params: { promptId: 'prompt-1', key: 'key', value: 'value1' },
+            });
+            // Overwrite with new value
+            await storage.use(storage.address, {
+                method: 'put',
+                params: { promptId: 'prompt-1', key: 'key', value: 'value2' },
+            });
+            // Verify new value
+            const result = await storage.use(storage.address, {
+                method: 'get',
+                params: { promptId: 'prompt-1', key: 'key' },
+            });
+            assertSuccess(result);
+            expect(result.result.data.value).to.equal('value2');
+        });
+    });
+    describe('Max Prompts Limit', () => {
+        it('should evict oldest prompt when max limit reached', async () => {
+            // Create storage with limit
+            await storage.stop();
+            storage = await new SimpleNodeBuilder(PromptStorageProvider)
+                .withAddress(new oNodeAddress('o://prompt-storage-test'))
+                .withConfig({ maxPrompts: 3 })
+                .build(env);
+            // Add 3 prompts
+            await storage.use(storage.address, {
+                method: 'put',
+                params: { promptId: 'prompt-1', key: 'key', value: 'value1' },
+            });
+            // Small delay to ensure different timestamps
+            await new Promise((resolve) => setTimeout(resolve, 10));
+            await storage.use(storage.address, {
+                method: 'put',
+                params: { promptId: 'prompt-2', key: 'key', value: 'value2' },
+            });
+            await new Promise((resolve) => setTimeout(resolve, 10));
+            await storage.use(storage.address, {
+                method: 'put',
+                params: { promptId: 'prompt-3', key: 'key', value: 'value3' },
+            });
+            // Verify all 3 exist
+            const before = await storage.use(storage.address, {
+                method: 'list_prompts',
+                params: {},
+            });
+            assertSuccess(before);
+            expect(before.result.data.count).to.equal(3);
+            // Add 4th prompt (should evict prompt-1)
+            await storage.use(storage.address, {
+                method: 'put',
+                params: { promptId: 'prompt-4', key: 'key', value: 'value4' },
+            });
+            // Verify only 3 prompts remain
+            const after = await storage.use(storage.address, {
+                method: 'list_prompts',
+                params: {},
+            });
+            assertSuccess(after);
+            expect(after.result.data.count).to.equal(3);
+            // Verify prompt-1 was evicted
+            const result1 = await storage.use(storage.address, {
+                method: 'get',
+                params: { promptId: 'prompt-1', key: 'key' },
+            });
+            assertSuccess(result1);
+            expect(result1.result.data.value).to.be.null;
+            // Verify prompt-4 exists
+            const result4 = await storage.use(storage.address, {
+                method: 'get',
+                params: { promptId: 'prompt-4', key: 'key' },
+            });
+            assertSuccess(result4);
+            expect(result4.result.data.value).to.equal('value4');
+        });
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@olane/o-lane",
-  "version": "0.7.12-alpha.76",
+  "version": "0.7.12",
   "type": "module",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",
@@ -36,11 +36,13 @@
   "devDependencies": {
     "@eslint/eslintrc": "^3.3.1",
     "@eslint/js": "^9.29.0",
+    "@olane/o-test": "0.7.12",
     "@tsconfig/node20": "^20.1.6",
     "@types/jest": "^30.0.0",
     "@typescript-eslint/eslint-plugin": "^8.34.1",
     "@typescript-eslint/parser": "^8.34.1",
     "aegir": "^47.0.21",
+    "chai": "^5.1.2",
     "eslint": "^9.29.0",
     "eslint-config-prettier": "^10.1.6",
     "eslint-plugin-prettier": "^5.5.0",
@@ -54,13 +56,14 @@
     "typescript": "5.4.5"
   },
   "dependencies": {
-    "@olane/o-config": "0.7.12-alpha.76",
-    "@olane/o-core": "0.7.12-alpha.76",
-    "@olane/o-node": "0.7.12-alpha.76",
-    "@olane/o-protocol": "0.7.12-alpha.76",
-    "@olane/o-tool": "0.7.12-alpha.76",
+    "@olane/o-config": "0.7.12",
+    "@olane/o-core": "0.7.12",
+    "@olane/o-node": "0.7.12",
+    "@olane/o-protocol": "0.7.12",
+    "@olane/o-storage": "0.7.12",
+    "@olane/o-tool": "0.7.12",
     "debug": "^4.4.1",
     "dotenv": "^16.5.0"
   },
-  "gitHead": "2824fcbb8216f9a579d37f5528f273d22419865d"
+  "gitHead": "580d8c51fe0a12695ba1d77f077029200f0c8af4"
 }

package/dist/src/ag-ui/ag-ui-constants.d.ts

@@ -1,90 +0,0 @@
-/**
- * AG-UI Protocol Constants
- */
-/**
- * AG-UI protocol version this implementation supports
- */
-export declare const AG_UI_PROTOCOL_VERSION = "1.0.0";
-/**
- * Default configuration values
- */
-export declare const AG_UI_DEFAULTS: {
-    /**
-     * Default state snapshot interval (every N cycles)
-     */
-    STATE_SNAPSHOT_INTERVAL: number;
-    /**
-     * Maximum delta history to keep
-     */
-    MAX_DELTA_HISTORY: number;
-    /**
-     * Default text chunk size for streaming
-     */
-    TEXT_CHUNK_SIZE: number;
-    /**
-     * Enable debug logging by default
-     */
-    DEBUG_ENABLED: boolean;
-    /**
-     * Enable AG-UI by default
-     */
-    AGUI_ENABLED: boolean;
-    /**
-     * Emit activity events by default
-     */
-    EMIT_ACTIVITY_EVENTS: boolean;
-    /**
-     * Emit reasoning events by default
-     */
-    EMIT_REASONING_EVENTS: boolean;
-    /**
-     * Include raw events by default
-     */
-    INCLUDE_RAW_EVENTS: boolean;
-    /**
-     * Auto-generate thread ID by default
-     */
-    AUTO_GENERATE_THREAD_ID: boolean;
-};
-/**
- * Activity types for AG-UI activity events
- */
-export declare const ACTIVITY_TYPES: {
-    readonly PLAN: "PLAN";
-    readonly EXECUTE: "EXECUTE";
-    readonly EVALUATE: "EVALUATE";
-    readonly SEARCH: "SEARCH";
-    readonly CONFIGURE: "CONFIGURE";
-    readonly ERROR: "ERROR";
-    readonly PROGRESS: "PROGRESS";
-};
-/**
- * Event type categories for filtering
- */
-export declare const EVENT_CATEGORIES: {
-    readonly LIFECYCLE: readonly ["RunStarted", "RunFinished", "RunError", "StepStarted", "StepFinished"];
-    readonly MESSAGES: readonly ["TextMessageStart", "TextMessageContent", "TextMessageEnd", "TextMessageChunk"];
-    readonly TOOL_CALLS: readonly ["ToolCallStart", "ToolCallArgs", "ToolCallEnd", "ToolCallResult", "ToolCallChunk"];
-    readonly STATE: readonly ["StateSnapshot", "StateDelta", "MessagesSnapshot"];
-    readonly ACTIVITY: readonly ["ActivitySnapshot", "ActivityDelta"];
-    readonly SPECIAL: readonly ["Raw", "Custom"];
-    readonly REASONING: readonly ["ReasoningStart", "ReasoningEnd", "ReasoningMessageStart", "ReasoningMessageContent", "ReasoningMessageEnd", "ReasoningMessageChunk"];
-};
-/**
- * Default message roles
- */
-export declare const MESSAGE_ROLES: {
-    readonly DEVELOPER: "developer";
-    readonly SYSTEM: "system";
-    readonly ASSISTANT: "assistant";
-    readonly USER: "user";
-    readonly TOOL: "tool";
-};
-/**
- * Run outcome types
- */
-export declare const RUN_OUTCOMES: {
-    readonly SUCCESS: "success";
-    readonly INTERRUPT: "interrupt";
-};
-//# sourceMappingURL=ag-ui-constants.d.ts.map

package/dist/src/ag-ui/ag-ui-constants.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ag-ui-constants.d.ts","sourceRoot":"","sources":["../../../src/ag-ui/ag-ui-constants.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;GAEG;AACH,eAAO,MAAM,sBAAsB,UAAU,CAAC;AAE9C;;GAEG;AACH,eAAO,MAAM,cAAc;IACzB;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;CAEJ,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,cAAc;;;;;;;;CAQjB,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;CAgCnB,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,aAAa;;;;;;CAMhB,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,YAAY;;;CAGf,CAAC"}