@easynet/agent-memory 1.0.57 → 1.0.58

package/dist/test/unit/create-agent-memory.test.js

@@ -1,4 +1,4 @@
-import { describe, it } from "node:test";
+import { it } from "node:test";
 import assert from "node:assert";
 import { join } from "node:path";
 import { writeFile, mkdir, rm } from "node:fs/promises";
@@ -6,146 +6,145 @@ import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
 import { pathToFileURL } from "node:url";
 import { createAgentMemory, createAgentMemoryRegistry } from "../../src/create-agent-memory.js";
-describe("createAgentMemory", () => {
-    it("memorize with content and type delegates to core memory", async () => {
-        const memoryRegistry = await createAgentMemoryRegistry({
-            config: {
-                stores: [{ id: "default", type: "in_memory" }],
-            },
-        });
-        const memory = await memoryRegistry.getAgentMemory();
-        const item = await memory.memorize("user:1", "cross_thread", "User likes cats.");
-        assert.ok(item.id);
-        assert.strictEqual(item.content, "User likes cats.");
-        assert.strictEqual(item.type, "cross_thread");
-        const result = await memory.recall({
-            namespace: "user:1",
-            query: "cats",
-            topK: 5,
-        });
-        assert.strictEqual(result.items.length, 1);
-    });
-    it("memorize supports auto type when type is omitted", async () => {
-        const memory = await createAgentMemory({
-            config: {
-                stores: [{ id: "default", type: "in_memory" }],
-            },
-            classifyMemory: async (content) => (content.includes("manual") ? "knowledge" : "cross_thread"),
-        });
-        const item = await memory.memorize("user:auto", "Product manual summary");
-        assert.strictEqual(item.type, "knowledge");
+it("memorize with content and type delegates to core memory", async () => {
+    const memoryRegistry = await createAgentMemoryRegistry({
+        config: {
+            stores: [{ id: "default", type: "in_memory" }],
+        },
     });
-    it("memorize supports positional parameters", async () => {
-        const memoryRegistry = await createAgentMemoryRegistry({
-            config: {
-                stores: [{ id: "default", type: "in_memory" }],
-            },
-        });
-        const memory = await memoryRegistry.getAgentMemory();
-        const item = await memory.memorize("user:positional", "knowledge", "Positional call.");
-        assert.ok(item.id);
-        assert.strictEqual(item.type, "knowledge");
-        assert.strictEqual(item.content, "Positional call.");
+    const memory = await memoryRegistry.getAgentMemory();
+    const item = await memory.memorize("user:1", "cross_thread", "User likes cats.");
+    assert.ok(item.id);
+    assert.strictEqual(item.content, "User likes cats.");
+    assert.strictEqual(item.type, "cross_thread");
+    const result = await memory.recall({
+        namespace: "user:1",
+        query: "cats",
+        topK: 5,
     });
-    it("memorize with url ingests file and stores chunks", async () => {
-        const dir = join(tmpdir(), `ingest-wrapper-${randomUUID()}`);
-        await mkdir(dir, { recursive: true });
-        const filePath = join(dir, "note.txt");
-        await writeFile(filePath, "Chunk one.\n\nChunk two.", "utf-8");
-        const memoryRegistry = await createAgentMemoryRegistry({
-            config: {
-                stores: [{ id: "default", type: "in_memory" }],
-            },
-        });
-        const memory = await memoryRegistry.getAgentMemory();
-        try {
-            const item = await memory.memorize("test", "knowledge", pathToFileURL(filePath));
-            assert.ok(item.id);
-            assert.strictEqual(item.type, "knowledge");
-            const result = await memory.recall({
-                namespace: "test",
-                query: "Chunk",
-                topK: 10,
-            });
-            assert.ok(result.items.length >= 1);
-        }
-        finally {
-            await rm(dir, { recursive: true, force: true }).catch(() => { });
-        }
+    assert.strictEqual(result.items.length, 1);
+});
+it("memorize supports auto type when type is omitted", async () => {
+    const memory = await createAgentMemory({
+        config: {
+            stores: [{ id: "default", type: "in_memory" }],
+        },
+        classifyMemory: async (content) => (content.includes("manual") ? "knowledge" : "cross_thread"),
     });
-    it("memorize with url supports classifier when type is omitted", async () => {
-        const dir = join(tmpdir(), `ingest-auto-url-${randomUUID()}`);
-        await mkdir(dir, { recursive: true });
-        const filePath = join(dir, "preference.txt");
-        await writeFile(filePath, "User preference: always answer in short bullets.", "utf-8");
-        const memory = await createAgentMemory({
-            config: {
-                stores: [{ id: "default", type: "in_memory" }],
-            },
-            classifyMemory: async (content) => (content.includes("preference") ? "cross_thread" : "knowledge"),
-        });
-        try {
-            const item = await memory.memorize("user:url-auto", pathToFileURL(filePath));
-            assert.strictEqual(item.type, "cross_thread");
-        }
-        finally {
-            await rm(dir, { recursive: true, force: true }).catch(() => { });
-        }
+    const item = await memory.memorize("user:auto", "Product manual summary");
+    assert.strictEqual(item.type, "knowledge");
+});
+it("memorize supports positional parameters", async () => {
+    const memoryRegistry = await createAgentMemoryRegistry({
+        config: {
+            stores: [{ id: "default", type: "in_memory" }],
+        },
     });
-    it("memorize without url and without content throws", async () => {
-        const memoryRegistry = await createAgentMemoryRegistry({
-            config: {
-                stores: [{ id: "default", type: "in_memory" }],
-            },
-        });
-        const memory = await memoryRegistry.getAgentMemory();
-        await assert.rejects(() => memory
-            .memorize("test", "knowledge", new URL("http://127.0.0.1:9/not-found.txt")), /request failed|fetch failed|ECONNREFUSED|Failed to fetch/);
+    const memory = await memoryRegistry.getAgentMemory();
+    const item = await memory.memorize("user:positional", "knowledge", "Positional call.");
+    assert.ok(item.id);
+    assert.strictEqual(item.type, "knowledge");
+    assert.strictEqual(item.content, "Positional call.");
+});
+it("memorize with url ingests file and stores chunks", async () => {
+    const dir = join(tmpdir(), `ingest-wrapper-${randomUUID()}`);
+    await mkdir(dir, { recursive: true });
+    const filePath = join(dir, "note.txt");
+    await writeFile(filePath, "Chunk one.\n\nChunk two.", "utf-8");
+    const memoryRegistry = await createAgentMemoryRegistry({
+        config: {
+            stores: [{ id: "default", type: "in_memory" }],
+        },
     });
-    it("memorize delegates to extended memorize", async () => {
-        const memoryRegistry = await createAgentMemoryRegistry({
-            config: {
-                stores: [{ id: "default", type: "in_memory" }],
-            },
-        });
-        const memory = await memoryRegistry.getAgentMemory();
-        const item = await memory.memorize("user:1", "cross_thread", "Written via write.");
+    const memory = await memoryRegistry.getAgentMemory();
+    try {
+        const item = await memory.memorize("test", "knowledge", pathToFileURL(filePath));
         assert.ok(item.id);
-        assert.strictEqual(item.content, "Written via write.");
+        assert.strictEqual(item.type, "knowledge");
         const result = await memory.recall({
-            namespace: "user:1",
-            query: "any",
-            topK: 5,
+            namespace: "test",
+            query: "Chunk",
+            topK: 10,
         });
-        assert.strictEqual(result.items.length, 1);
+        assert.ok(result.items.length >= 1);
+    }
+    finally {
+        await rm(dir, { recursive: true, force: true }).catch(() => { });
+    }
+});
+it("memorize with url supports classifier when type is omitted", async () => {
+    const dir = join(tmpdir(), `ingest-auto-url-${randomUUID()}`);
+    await mkdir(dir, { recursive: true });
+    const filePath = join(dir, "preference.txt");
+    await writeFile(filePath, "User preference: always answer in short bullets.", "utf-8");
+    const memory = await createAgentMemory({
+        config: {
+            stores: [{ id: "default", type: "in_memory" }],
+        },
+        classifyMemory: async (content) => (content.includes("preference") ? "cross_thread" : "knowledge"),
     });
-    it("recall delegates to underlying memory", async () => {
-        const memoryRegistry = await createAgentMemoryRegistry({
-            config: {
-                stores: [{ id: "default", type: "in_memory" }],
-            },
-        });
-        const memory = await memoryRegistry.getAgentMemory();
-        await memory.memorize("ns", "knowledge", "Delegation test.");
-        const recallResult = await memory.recall({
-            namespace: "ns",
-            query: "Delegation",
-            topK: 5,
-        });
-        assert.strictEqual(recallResult.items.length, 1);
-        const promptResult = await memory.recall({
-            namespace: "ns",
-            query: "test",
-            topK: 5,
-        });
-        assert.strictEqual(promptResult.items.length, 1);
-        assert.ok(promptResult.traceId);
+    try {
+        const item = await memory.memorize("user:url-auto", pathToFileURL(filePath));
+        assert.strictEqual(item.type, "cross_thread");
+    }
+    finally {
+        await rm(dir, { recursive: true, force: true }).catch(() => { });
+    }
+});
+it("memorize without url and without content throws", async () => {
+    const memoryRegistry = await createAgentMemoryRegistry({
+        config: {
+            stores: [{ id: "default", type: "in_memory" }],
+        },
+    });
+    const memory = await memoryRegistry.getAgentMemory();
+    await assert.rejects(() => memory
+        .memorize("test", "knowledge", new URL("http://127.0.0.1:9/not-found.txt")), /request failed|fetch failed|ECONNREFUSED|Failed to fetch/);
+});
+it("memorize delegates to extended memorize", async () => {
+    const memoryRegistry = await createAgentMemoryRegistry({
+        config: {
+            stores: [{ id: "default", type: "in_memory" }],
+        },
+    });
+    const memory = await memoryRegistry.getAgentMemory();
+    const item = await memory.memorize("user:1", "cross_thread", "Written via write.");
+    assert.ok(item.id);
+    assert.strictEqual(item.content, "Written via write.");
+    const result = await memory.recall({
+        namespace: "user:1",
+        query: "any",
+        topK: 5,
+    });
+    assert.strictEqual(result.items.length, 1);
+});
+it("recall delegates to underlying memory", async () => {
+    const memoryRegistry = await createAgentMemoryRegistry({
+        config: {
+            stores: [{ id: "default", type: "in_memory" }],
+        },
     });
-    it("supports extension provider via local module path", async () => {
-        const dir = join(tmpdir(), `memory-ext-${randomUUID()}`);
-        await mkdir(dir, { recursive: true });
-        const extPath = join(dir, "provider.mjs");
-        await writeFile(extPath, `
+    const memory = await memoryRegistry.getAgentMemory();
+    await memory.memorize("ns", "knowledge", "Delegation test.");
+    const recallResult = await memory.recall({
+        namespace: "ns",
+        query: "Delegation",
+        topK: 5,
+    });
+    assert.strictEqual(recallResult.items.length, 1);
+    const promptResult = await memory.recall({
+        namespace: "ns",
+        query: "test",
+        topK: 5,
+    });
+    assert.strictEqual(promptResult.items.length, 1);
+    assert.ok(promptResult.traceId);
+});
+it("supports extension provider via local module path", async () => {
+    const dir = join(tmpdir(), `memory-ext-${randomUUID()}`);
+    await mkdir(dir, { recursive: true });
+    const extPath = join(dir, "provider.mjs");
+    await writeFile(extPath, `
 export function createMemoryProvider() {
   const rows = [];
   return {
@@ -172,200 +171,199 @@ export function createMemoryProvider() {
   };
 }
 `, "utf-8");
-        try {
-            const memoryRegistry = await createAgentMemoryRegistry({
-                config: {
-                    stores: [
-                        {
-                            id: "ext",
-                            type: "extension",
-                            options: { package: extPath },
-                        },
-                    ],
-                },
-            });
-            const memory = await memoryRegistry.getAgentMemory();
-            const item = await memory.memorize("ext:ns", "knowledge", "Extension provider content");
-            assert.strictEqual(item.id, "ext-1");
-            const result = await memory.recall({
-                namespace: "ext:ns",
-                query: "Extension",
-                topK: 5,
-            });
-            assert.strictEqual(result.items.length, 1);
-            assert.strictEqual(result.items[0]?.content, "Extension provider content");
-        }
-        finally {
-            await rm(dir, { recursive: true, force: true }).catch(() => { });
-        }
-    });
-    it("llamaindex provider falls back to knowledge type when metadata.type is missing", async () => {
-        class FakeKnowledgeProvider {
-            async remember(req) {
-                return {
-                    id: "k-1",
-                    content: req.content ?? "",
-                    metadata: req.metadata,
-                };
-            }
-            async recall() {
-                return [
-                    {
-                        id: "k-1",
-                        content: "knowledge-content",
-                        metadata: {},
-                    },
-                ];
-            }
-            async forget() { }
-        }
+    try {
         const memoryRegistry = await createAgentMemoryRegistry({
             config: {
-                stores: [{ id: "k", type: "llamaindex", options: {} }],
-            },
-            overrides: {
-                providerCtors: {
-                    llamaindex: FakeKnowledgeProvider,
-                },
+                stores: [
+                    {
+                        id: "ext",
+                        type: "extension",
+                        options: { package: extPath },
+                    },
+                ],
             },
         });
         const memory = await memoryRegistry.getAgentMemory();
+        const item = await memory.memorize("ext:ns", "knowledge", "Extension provider content");
+        assert.strictEqual(item.id, "ext-1");
         const result = await memory.recall({
-            namespace: "user:1",
-            query: "k",
+            namespace: "ext:ns",
+            query: "Extension",
             topK: 5,
         });
         assert.strictEqual(result.items.length, 1);
-        assert.strictEqual(result.items[0]?.type, "knowledge");
+        assert.strictEqual(result.items[0]?.content, "Extension provider content");
+    }
+    finally {
+        await rm(dir, { recursive: true, force: true }).catch(() => { });
+    }
+});
+it("llamaindex provider falls back to knowledge type when metadata.type is missing", async () => {
+    class FakeKnowledgeProvider {
+        async remember(req) {
+            return {
+                id: "k-1",
+                content: req.content ?? "",
+                metadata: req.metadata,
+            };
+        }
+        async recall() {
+            return [
+                {
+                    id: "k-1",
+                    content: "knowledge-content",
+                    metadata: {},
+                },
+            ];
+        }
+        async forget() { }
+    }
+    const memoryRegistry = await createAgentMemoryRegistry({
+        config: {
+            stores: [{ id: "k", type: "llamaindex", options: {} }],
+        },
+        overrides: {
+            providerCtors: {
+                llamaindex: FakeKnowledgeProvider,
+            },
+        },
     });
-    it("sqlite_vec provider falls back to cross_thread type when metadata.type is missing", async () => {
-        class FakeLongTermProvider {
-            async remember(req) {
-                return {
+    const memory = await memoryRegistry.getAgentMemory();
+    const result = await memory.recall({
+        namespace: "user:1",
+        query: "k",
+        topK: 5,
+    });
+    assert.strictEqual(result.items.length, 1);
+    assert.strictEqual(result.items[0]?.type, "knowledge");
+});
+it("sqlite_vec provider falls back to cross_thread type when metadata.type is missing", async () => {
+    class FakeLongTermProvider {
+        async remember(req) {
+            return {
+                id: "lt-1",
+                content: req.content ?? "",
+                metadata: req.metadata,
+            };
+        }
+        async recall() {
+            return [
+                {
                     id: "lt-1",
-                    content: req.content ?? "",
-                    metadata: req.metadata,
-                };
-            }
-            async recall() {
-                return [
-                    {
-                        id: "lt-1",
-                        content: "longterm-content",
-                        metadata: {},
-                    },
-                ];
-            }
-            async forget() { }
+                    content: "longterm-content",
+                    metadata: {},
+                },
+            ];
         }
-        const memoryRegistry = await createAgentMemoryRegistry({
-            config: {
-                stores: [{ id: "lt", type: "sqlite_vec", options: { dbPath: ":memory:", dimensions: 1024 } }],
+        async forget() { }
+    }
+    const memoryRegistry = await createAgentMemoryRegistry({
+        config: {
+            stores: [{ id: "lt", type: "sqlite_vec", options: { dbPath: ":memory:", dimensions: 1024 } }],
+        },
+        overrides: {
+            providerCtors: {
+                sqliteVec: FakeLongTermProvider,
             },
-            overrides: {
-                providerCtors: {
-                    sqliteVec: FakeLongTermProvider,
+        },
+    });
+    const memory = await memoryRegistry.getAgentMemory();
+    const result = await memory.recall({
+        namespace: "user:1",
+        query: "lt",
+        topK: 5,
+    });
+    assert.strictEqual(result.items.length, 1);
+    assert.strictEqual(result.items[0]?.type, "cross_thread");
+});
+it("llamaindex provider gets VLM model from overrides into context", async () => {
+    class FakeKnowledgeProviderWithContext {
+        options;
+        constructor(options) {
+            this.options = options;
+        }
+        async remember(req) {
+            const context = this.options.context;
+            const agentModel = context?.agentModel;
+            const vlm = agentModel?.vlm;
+            return {
+                id: "k-vlm-1",
+                content: req.content ?? "",
+                metadata: {
+                    ...(req.metadata ?? {}),
+                    vlm_model_id: typeof vlm?.id === "string" ? vlm.id : undefined,
                 },
+            };
+        }
+        async recall() {
+            return [];
+        }
+        async forget() { }
+    }
+    const memoryRegistry = await createAgentMemoryRegistry({
+        config: {
+            stores: [{ id: "k", type: "llamaindex", options: {} }],
+            vlm: { useAgentModel: true },
+        },
+        overrides: {
+            agentModelVlm: { id: "vlm-demo", provider: "openai", model: "gpt-4o-mini" },
+            providerCtors: {
+                llamaindex: FakeKnowledgeProviderWithContext,
             },
-        });
-        const memory = await memoryRegistry.getAgentMemory();
-        const result = await memory.recall({
-            namespace: "user:1",
-            query: "lt",
-            topK: 5,
-        });
-        assert.strictEqual(result.items.length, 1);
-        assert.strictEqual(result.items[0]?.type, "cross_thread");
+        },
     });
-    it("llamaindex provider gets VLM model from overrides into context", async () => {
-        class FakeKnowledgeProviderWithContext {
-            options;
-            constructor(options) {
-                this.options = options;
-            }
-            async remember(req) {
-                const context = this.options.context;
-                const agentModel = context?.agentModel;
-                const vlm = agentModel?.vlm;
-                return {
-                    id: "k-vlm-1",
-                    content: req.content ?? "",
-                    metadata: {
-                        ...(req.metadata ?? {}),
-                        vlm_model_id: typeof vlm?.id === "string" ? vlm.id : undefined,
+    const memory = await memoryRegistry.getAgentMemory();
+    const item = await memory.memorize("user:vlm", "knowledge", "Image summary.");
+    assert.strictEqual(item.metadata?.vlm_model_id, "vlm-demo");
+});
+it("supports session compaction from config", async () => {
+    const memoryRegistry = await createAgentMemoryRegistry({
+        config: {
+            stores: [{ id: "default", type: "in_memory" }],
+            memory: {
+                thread: {
+                    sessionCompaction: {
+                        enabled: true,
+                        maxTokens: 8,
+                        keepRecentTurns: 1,
+                        summaryKey: "__summary__",
+                        checkEveryTurns: 1,
                     },
-                };
-            }
-            async recall() {
-                return [];
-            }
-            async forget() { }
-        }
-        const memoryRegistry = await createAgentMemoryRegistry({
-            config: {
-                stores: [{ id: "k", type: "llamaindex", options: {} }],
-                vlm: { useAgentModel: true },
-            },
-            overrides: {
-                agentModelVlm: { id: "vlm-demo", provider: "openai", model: "gpt-4o-mini" },
-                providerCtors: {
-                    llamaindex: FakeKnowledgeProviderWithContext,
                 },
             },
-        });
-        const memory = await memoryRegistry.getAgentMemory();
-        const item = await memory.memorize("user:vlm", "knowledge", "Image summary.");
-        assert.strictEqual(item.metadata?.vlm_model_id, "vlm-demo");
+        },
+        summarizeSessionTurns: async ({ oldTurns }) => `summary(${oldTurns.length})`,
     });
-    it("supports session compaction from config", async () => {
+    const memory = await memoryRegistry.getAgentMemory();
+    await memory.memorize("session:demo", "thread", "A".repeat(40));
+    await memory.memorize("session:demo", "thread", "B".repeat(40));
+    const summary = await memory.getByKey("session:demo", "__summary__");
+    assert.ok(summary);
+    assert.strictEqual(summary?.type, "thread");
+    assert.strictEqual(summary?.content, "summary(1)");
+});
+it("rejects provider key in typed store config blocks", async () => {
+    await assert.rejects(async () => {
         const memoryRegistry = await createAgentMemoryRegistry({
             config: {
-                stores: [{ id: "default", type: "in_memory" }],
                 memory: {
-                    thread: {
-                        sessionCompaction: {
-                            enabled: true,
-                            maxTokens: 8,
-                            keepRecentTurns: 1,
-                            summaryKey: "__summary__",
-                            checkEveryTurns: 1,
-                        },
-                    },
-                },
-            },
-            summarizeSessionTurns: async ({ oldTurns }) => `summary(${oldTurns.length})`,
-        });
-        const memory = await memoryRegistry.getAgentMemory();
-        await memory.memorize("session:demo", "thread", "A".repeat(40));
-        await memory.memorize("session:demo", "thread", "B".repeat(40));
-        const summary = await memory.getByKey("session:demo", "__summary__");
-        assert.ok(summary);
-        assert.strictEqual(summary?.type, "thread");
-        assert.strictEqual(summary?.content, "summary(1)");
-    });
-    it("rejects provider key in typed store config blocks", async () => {
-        await assert.rejects(async () => {
-            const memoryRegistry = await createAgentMemoryRegistry({
-                config: {
-                    memory: {
-                        thread: { store: { type: "in_memory" } },
-                        cross_thread: {
-                            store: {
-                                type: "mem0",
-                                config: {
-                                    vectorStore: {
-                                        provider: "qdrant",
-                                        config: { host: "localhost", port: 6333 },
-                                    },
+                    thread: { store: { type: "in_memory" } },
+                    cross_thread: {
+                        store: {
+                            type: "mem0",
+                            config: {
+                                vectorStore: {
+                                    provider: "qdrant",
+                                    config: { host: "localhost", port: 6333 },
                                 },
                             },
                         },
-                        knowledge: { store: { type: "in_memory" } },
                     },
+                    knowledge: { store: { type: "in_memory" } },
                 },
-            });
-            await memoryRegistry.getAgentMemory();
-        }, /provider.*type/i);
-    });
+            },
+        });
+        await memoryRegistry.getAgentMemory();
+    }, /provider.*type/i);
 });
 //# sourceMappingURL=create-agent-memory.test.js.map