@aigne/default-memory 1.0.0

package/lib/esm/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./default-memory-storage/index.js";
+export * from "./memory.js";
+export * from "./storage.js";

package/lib/esm/index.js

@@ -0,0 +1,3 @@
+export * from "./default-memory-storage/index.js";
+export * from "./memory.js";
+export * from "./storage.js";

package/lib/esm/memory.d.ts

@@ -0,0 +1,44 @@
+import { type AgentInvokeOptions, type AgentOptions, MemoryAgent, type MemoryAgentOptions, MemoryRecorder, type MemoryRecorderInput, type MemoryRecorderOutput, MemoryRetriever, type MemoryRetrieverInput, type MemoryRetrieverOutput } from "@aigne/core";
+import { type DefaultMemoryStorageOptions } from "./default-memory-storage/index.js";
+import { MemoryStorage } from "./storage.js";
+export interface DefaultMemoryOptions extends Partial<MemoryAgentOptions>, Omit<DefaultMemoryRecorderOptions, "storage" | keyof AgentOptions>, Omit<DefaultMemoryRetrieverOptions, "storage" | keyof AgentOptions> {
+    storage?: MemoryStorage | DefaultMemoryStorageOptions;
+}
+export declare class DefaultMemory extends MemoryAgent {
+    constructor(options?: DefaultMemoryOptions);
+    storage: MemoryStorage;
+}
+export interface DefaultMemoryRetrieverOptions extends AgentOptions<MemoryRetrieverInput, MemoryRetrieverOutput> {
+    storage: MemoryStorage;
+    retrieveMemoryCount?: number;
+    retrieveRecentMemoryCount?: number;
+    inputKey?: string | string[];
+    outputKey?: string | string[];
+    getSearchPattern?: DefaultMemoryRetriever["getSearchPattern"];
+    formatMessage?: DefaultMemoryRetriever["formatMessage"];
+    formatMemory?: DefaultMemoryRetriever["formatMemory"];
+}
+export declare class DefaultMemoryRetriever extends MemoryRetriever {
+    constructor(options: DefaultMemoryRetrieverOptions);
+    private storage;
+    private retrieveMemoryCount?;
+    private retrieveRecentMemoryCount?;
+    private inputKey?;
+    private outputKey?;
+    private getSearchPattern;
+    private formatMessage;
+    private formatMemory;
+    process(input: MemoryRetrieverInput, options: AgentInvokeOptions): Promise<MemoryRetrieverOutput>;
+}
+export interface DefaultMemoryRecorderOptions extends AgentOptions<MemoryRecorderInput, MemoryRecorderOutput> {
+    storage: MemoryStorage;
+    inputKey?: string | string[];
+    outputKey?: string | string[];
+}
+export declare class DefaultMemoryRecorder extends MemoryRecorder {
+    constructor(options: DefaultMemoryRecorderOptions);
+    private storage;
+    private inputKey?;
+    private outputKey?;
+    process(input: MemoryRecorderInput, options: AgentInvokeOptions): Promise<MemoryRecorderOutput>;
+}

package/lib/esm/memory.js

@@ -0,0 +1,131 @@
+import { MemoryAgent, MemoryRecorder, MemoryRetriever, } from "@aigne/core";
+import { flat, isRecord, pick } from "@aigne/core/utils/type-utils.js";
+import { DefaultMemoryStorage, } from "./default-memory-storage/index.js";
+import { MemoryStorage } from "./storage.js";
+const DEFAULT_RETRIEVE_MEMORY_COUNT = 10;
+export class DefaultMemory extends MemoryAgent {
+    constructor(options = {}) {
+        const storage = options.storage instanceof MemoryStorage
+            ? options.storage
+            : new DefaultMemoryStorage(options.storage);
+        super({
+            ...options,
+            recorder: options.recorder ?? new DefaultMemoryRecorder({ ...options, storage }),
+            retriever: options.retriever ??
+                new DefaultMemoryRetriever({
+                    ...options,
+                    retrieveRecentMemoryCount: options.retrieveRecentMemoryCount ??
+                        Math.ceil(options.retrieveMemoryCount ?? DEFAULT_RETRIEVE_MEMORY_COUNT) / 2,
+                    storage,
+                }),
+            autoUpdate: options.autoUpdate ?? true,
+        });
+        this.storage = storage;
+    }
+    storage;
+}
+export class DefaultMemoryRetriever extends MemoryRetriever {
+    constructor(options) {
+        super(options);
+        this.storage = options.storage;
+        this.retrieveMemoryCount = options.retrieveMemoryCount;
+        this.retrieveRecentMemoryCount = options.retrieveRecentMemoryCount;
+        this.inputKey = flat(options.inputKey);
+        this.outputKey = flat(options.outputKey);
+        if (options.getSearchPattern)
+            this.getSearchPattern = options.getSearchPattern;
+        if (options.formatMessage)
+            this.formatMessage = options.formatMessage;
+        if (options.formatMemory)
+            this.formatMemory = options.formatMemory;
+    }
+    storage;
+    retrieveMemoryCount;
+    retrieveRecentMemoryCount;
+    inputKey;
+    outputKey;
+    getSearchPattern = (search) => {
+        if (!search || typeof search === "string")
+            return search;
+        const obj = search && this.inputKey ? pick(search, this.inputKey) : search;
+        return Object.values(obj)
+            .map((v) => (typeof v === "string" ? v : undefined))
+            .join("\n");
+    };
+    formatMessage = (content, key) => {
+        if (!isRecord(content))
+            return content;
+        const obj = !key?.length ? content : pick(content, key);
+        return Object.values(obj)
+            .map((v) => (typeof v === "string" ? v : undefined))
+            .join("\n");
+    };
+    formatMemory = (content) => {
+        if (isRecord(content) && "input" in content && "output" in content) {
+            return {
+                input: this.formatMessage(content.input, this.inputKey),
+                output: this.formatMessage(content.output, this.outputKey),
+                source: content.source,
+            };
+        }
+        return content;
+    };
+    async process(input, options) {
+        const limit = input.limit ?? this.retrieveMemoryCount ?? DEFAULT_RETRIEVE_MEMORY_COUNT;
+        const search = this.getSearchPattern(input.search);
+        const recentLimit = this.retrieveRecentMemoryCount;
+        const [recent, related] = await Promise.all([
+            // Query latest messages
+            !recentLimit
+                ? []
+                : this.storage
+                    .search({ limit: recentLimit, orderBy: ["createdAt", "desc"] }, options)
+                    .then(({ result }) => result.reverse()),
+            // Query related messages
+            !input.search
+                ? []
+                : this.storage.search({ ...input, search, limit }, options).then(({ result }) => result),
+        ]);
+        const recentSet = new Set(recent.map((i) => i.id));
+        const memories = related
+            // Filter out recent memories from related results
+            .filter((i) => !recentSet.has(i.id))
+            .concat(recent)
+            .slice(-limit);
+        return {
+            memories: memories.map((i) => ({
+                ...i,
+                content: this.formatMemory(i.content),
+            })),
+        };
+    }
+}
+export class DefaultMemoryRecorder extends MemoryRecorder {
+    constructor(options) {
+        super(options);
+        this.storage = options.storage;
+        this.inputKey = flat(options.inputKey);
+        this.outputKey = flat(options.outputKey);
+    }
+    storage;
+    inputKey;
+    outputKey;
+    async process(input, options) {
+        const newMemories = [];
+        for (const item of input.content) {
+            const { result } = await this.storage.create({
+                content: {
+                    input: item.input && this.inputKey?.length ? pick(item.input, this.inputKey) : item.input,
+                    output: item.output && this.outputKey?.length
+                        ? pick(item.output, this.outputKey)
+                        : item.output,
+                    source: item.source,
+                },
+            }, options);
+            newMemories.push(result);
+        }
+        return {
+            memories: newMemories,
+        };
+    }
+}

package/lib/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/lib/esm/storage.d.ts

@@ -0,0 +1,13 @@
+import type { AgentInvokeOptions, Memory } from "@aigne/core";
+export declare abstract class MemoryStorage {
+    abstract create(memory: Pick<Memory, "content">, options: AgentInvokeOptions): Promise<{
+        result: Memory;
+    }>;
+    abstract search(query: {
+        search?: string;
+        limit?: number;
+        orderBy?: [string, "asc" | "desc"];
+    }, options: AgentInvokeOptions): Promise<{
+        result: Memory[];
+    }>;
+}

package/lib/esm/storage.js

@@ -0,0 +1,2 @@
+export class MemoryStorage {
+}

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@aigne/default-memory",
+  "version": "1.0.0",
+  "description": "Default memory for AIGNE framework",
+  "publishConfig": {
+    "access": "public"
+  },
+  "author": "Arcblock <blocklet@arcblock.io> https://github.com/blocklet",
+  "homepage": "https://github.com/AIGNE-io/aigne-framework/tree/main/memory/default",
+  "license": "Elastic-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/AIGNE-io/aigne-framework"
+  },
+  "files": [
+    "lib/cjs",
+    "lib/dts",
+    "lib/esm",
+    "LICENSE",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "type": "module",
+  "main": "./lib/cjs/index.js",
+  "module": "./lib/esm/index.js",
+  "types": "./lib/dts/index.d.ts",
+  "dependencies": {
+    "drizzle-orm": "^0.44.2",
+    "uuid": "^11.1.0",
+    "yaml": "^2.8.0",
+    "zod": "^3.25.67",
+    "@aigne/core": "^1.34.0",
+    "@aigne/sqlite": "^0.4.0"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.2.18",
+    "npm-run-all": "^4.1.5",
+    "rimraf": "^6.0.1",
+    "typescript": "^5.8.3",
+    "@aigne/openai": "^0.10.0"
+  },
+  "scripts": {
+    "lint": "tsc --noEmit",
+    "build": "tsc --build scripts/tsconfig.build.json",
+    "clean": "rimraf lib test/coverage",
+    "test": "bun test",
+    "test:coverage": "bun test --coverage --coverage-reporter=lcov --coverage-reporter=text",
+    "postbuild": "node ../../scripts/post-build-lib.mjs"
+  }
+}