@aigne/default-memory 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,18 @@
+# Changelog
+
+## 1.0.0 (2025-07-15)
+
+
+### Features
+
+* **memory:** support did space memory adapter ([#229](https://github.com/AIGNE-io/aigne-framework/issues/229)) ([6f69b64](https://github.com/AIGNE-io/aigne-framework/commit/6f69b64e98b963db9d6ab5357306b445385eaa68))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @aigne/core bumped to 1.34.0
+    * @aigne/sqlite bumped to 0.4.0
+  * devDependencies
+    * @aigne/openai bumped to 0.10.0

package/LICENSE.md

@@ -0,0 +1,93 @@
+Elastic License 2.0
+
+URL: https://www.elastic.co/licensing/elastic-license
+
+## Acceptance
+
+By using the software, you agree to all of the terms and conditions below.
+
+## Copyright License
+
+The licensor grants you a non-exclusive, royalty-free, worldwide,
+non-sublicensable, non-transferable license to use, copy, distribute, make
+available, and prepare derivative works of the software, in each case subject to
+the limitations and conditions below.
+
+## Limitations
+
+You may not provide the software to third parties as a hosted or managed
+service, where the service provides users with access to any substantial set of
+the features or functionality of the software.
+
+You may not move, change, disable, or circumvent the license key functionality
+in the software, and you may not remove or obscure any functionality in the
+software that is protected by the license key.
+
+You may not alter, remove, or obscure any licensing, copyright, or other notices
+of the licensor in the software. Any use of the licensor’s trademarks is subject
+to applicable law.
+
+## Patents
+
+The licensor grants you a license, under any patent claims the licensor can
+license, or becomes able to license, to make, have made, use, sell, offer for
+sale, import and have imported the software, in each case subject to the
+limitations and conditions in this license. This license does not cover any
+patent claims that you cause to be infringed by modifications or additions to
+the software. If you or your company make any written claim that the software
+infringes or contributes to infringement of any patent, your patent license for
+the software granted under these terms ends immediately. If your company makes
+such a claim, your patent license ends immediately for work on behalf of your
+company.
+
+## Notices
+
+You must ensure that anyone who gets a copy of any part of the software from you
+also gets a copy of these terms.
+
+If you modify the software, you must include in any modified copies of the
+software prominent notices stating that you have modified the software.
+
+## No Other Rights
+
+These terms do not imply any licenses other than those expressly granted in
+these terms.
+
+## Termination
+
+If you use the software in violation of these terms, such use is not licensed,
+and your licenses will automatically terminate. If the licensor provides you
+with a notice of your violation, and you cease all violation of this license no
+later than 30 days after you receive that notice, your licenses will be
+reinstated retroactively. However, if you violate these terms after such
+reinstatement, any additional violation of these terms will cause your licenses
+to terminate automatically and permanently.
+
+## No Liability
+
+*As far as the law allows, the software comes as is, without any warranty or
+condition, and the licensor will not be liable to you for any damages arising
+out of these terms or the use or nature of the software, under any kind of
+legal claim.*
+
+## Definitions
+
+The **licensor** is the entity offering these terms, and the **software** is the
+software the licensor makes available under these terms, including any portion
+of it.
+
+**you** refers to the individual or entity agreeing to these terms.
+
+**your company** is any legal entity, sole proprietorship, or other kind of
+organization that you work for, plus all organizations that have control over,
+are under the control of, or are under common control with that
+organization. **control** means ownership of substantially all the assets of an
+entity, or the power to direct its management and policies by vote, contract, or
+otherwise. Control can be direct or indirect.
+
+**your licenses** are all the licenses granted to you for the software under
+these terms.
+
+**use** means anything you do with the software requiring one of your licenses.
+
+**trademark** means trademarks, service marks, and similar rights.

package/README.md

@@ -0,0 +1,167 @@
+# @aigne/default-memory
+
+[![GitHub star chart](https://img.shields.io/github/stars/AIGNE-io/aigne-framework?style=flat-square)](https://star-history.com/#AIGNE-io/aigne-framework)
+[![Open Issues](https://img.shields.io/github/issues-raw/AIGNE-io/aigne-framework?style=flat-square)](https://github.com/AIGNE-io/aigne-framework/issues)
+[![codecov](https://codecov.io/gh/AIGNE-io/aigne-framework/graph/badge.svg?token=DO07834RQL)](https://codecov.io/gh/AIGNE-io/aigne-framework)
+[![NPM Version](https://img.shields.io/npm/v/@aigne/default-memory)](https://www.npmjs.com/package/@aigne/default-memory)
+[![Elastic-2.0 licensed](https://img.shields.io/npm/l/@aigne/default-memory)](https://github.com/AIGNE-io/aigne-framework/blob/main/LICENSE)
+
+Default memory system component for [AIGNE Framework](https://github.com/AIGNE-io/aigne-framework), providing SQLite-based memory storage capabilities.
+
+## Introduction
+
+`@aigne/default-memory` is the default memory system component of [AIGNE Framework](https://github.com/AIGNE-io/aigne-framework), providing SQLite database-based memory storage and retrieval functionality. This component implements standard memory management interfaces and is an ideal choice for building AI applications.
+
+## Features
+
+* **SQLite Storage**: Uses SQLite database for reliable memory persistence
+* **Memory Retrieval**: Supports similarity-based memory retrieval
+* **Automatic Memory Updates**: Supports automatic memory update mechanisms
+* **Memory Statistics**: Provides storage and retrieval statistics for memories
+* **Flexible Configuration**: Supports custom memory retrieval count and related configurations
+* **TypeScript Support**: Complete type definitions providing an excellent development experience
+
+## Installation
+
+### Using npm
+
+```bash
+npm install @aigne/default-memory
+```
+
+### Using yarn
+
+```bash
+yarn add @aigne/default-memory
+```
+
+### Using pnpm
+
+```bash
+pnpm add @aigne/default-memory
+```
+
+## Basic Usage
+
+```typescript
+import { AIAgent, AIGNE } from "@aigne/core";
+import { DefaultMemory } from "@aigne/default-memory";
+import { OpenAIChatModel } from "@aigne/openai";
+
+// Create AI model instance
+const model = new OpenAIChatModel({
+  apiKey: process.env.OPENAI_API_KEY,
+  model: "gpt-4-turbo",
+});
+
+// Create default memory system
+const memory = new DefaultMemory({
+  storage: {
+    url: "file:memory.db",
+  },
+  retrieveMemoryCount: 10,
+  retrieveRecentMemoryCount: 5,
+  autoUpdate: true,
+});
+
+// Create AI agent with memory
+const agent = AIAgent.from({
+  name: "Assistant",
+  instructions: "You are a helpful assistant with memory capabilities.",
+  memory: memory,
+  inputKey: "message",
+});
+
+// Use AIGNE execution engine
+const aigne = new AIGNE({ model });
+
+// Invoke agent
+const userAgent = await aigne.invoke(agent);
+
+// Send message
+const response = await userAgent.invoke({
+  message: "My name is John and I work as a software developer",
+});
+
+console.log(response.message);
+
+// Query memory later
+const response2 = await userAgent.invoke({
+  message: "What do you remember about me?",
+});
+
+console.log(response2.message);
+```
+
+## Advanced Configuration
+
+### Custom Storage Configuration
+
+```typescript
+import { DefaultMemory, DefaultMemoryStorage } from "@aigne/default-memory";
+
+// Use custom storage configuration
+const memory = new DefaultMemory({
+  storage: {
+    url: "file:custom-memory.db",
+    // Other storage configurations
+  },
+  retrieveMemoryCount: 20,
+  retrieveRecentMemoryCount: 10,
+});
+
+// Or use custom storage instance
+const customStorage = new DefaultMemoryStorage({
+  url: "file:custom-memory.db",
+});
+
+const memory2 = new DefaultMemory({
+  storage: customStorage,
+});
+```
+
+### Configure Memory Retrieval Options
+
+```typescript
+const memory = new DefaultMemory({
+  storage: {
+    url: "file:memory.db",
+  },
+  // Set total number of memories to retrieve
+  retrieveMemoryCount: 15,
+  // Set number of recent memories to retrieve
+  retrieveRecentMemoryCount: 8,
+  // Enable auto update
+  autoUpdate: true,
+});
+```
+
+## Using with Multiple Agents
+
+```typescript
+import { DefaultMemory } from "@aigne/default-memory";
+
+// Create shared memory system
+const sharedMemory = new DefaultMemory({
+  storage: {
+    url: "file:shared-memory.db",
+  },
+});
+
+// Multiple agents can share the same memory system
+const agent1 = AIAgent.from({
+  name: "Agent1",
+  instructions: "You are assistant 1",
+  memory: sharedMemory,
+});
+
+const agent2 = AIAgent.from({
+  name: "Agent2", 
+  instructions: "You are assistant 2",
+  memory: sharedMemory,
+});
+```
+
+## License
+
+Elastic-2.0

package/lib/cjs/default-memory-storage/index.d.ts

@@ -0,0 +1,29 @@
+import type { AgentInvokeOptions, Context, Memory } from "@aigne/core";
+import type { PromiseOrValue } from "@aigne/core/utils/type-utils.js";
+import type { SqliteRemoteDatabase } from "drizzle-orm/sqlite-proxy";
+import { MemoryStorage } from "../storage.js";
+import { Memories } from "./models/memory.js";
+export interface DefaultMemoryStorageOptions {
+    url?: string;
+    getSessionId?: (context: Context) => PromiseOrValue<string>;
+    enableFTS?: boolean;
+}
+export declare class DefaultMemoryStorage extends MemoryStorage {
+    options?: DefaultMemoryStorageOptions | undefined;
+    constructor(options?: DefaultMemoryStorageOptions | undefined);
+    private _db;
+    private initSqlite;
+    get db(): Promise<SqliteRemoteDatabase<Record<string, never>>>;
+    private convertMemory;
+    search(query: {
+        search?: string;
+        limit?: number;
+        orderBy?: [keyof typeof Memories.$inferSelect, "asc" | "desc"];
+    }, { context }: AgentInvokeOptions): Promise<{
+        result: Memory[];
+    }>;
+    create(memory: Pick<Memory, "content">, { context }: AgentInvokeOptions): Promise<{
+        result: Memory;
+    }>;
+    protected segment(str: string): string[];
+}

package/lib/cjs/default-memory-storage/index.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultMemoryStorage = void 0;
+const sqlite_1 = require("@aigne/sqlite");
+const drizzle_orm_1 = require("drizzle-orm");
+const uuid_1 = require("uuid");
+const yaml_1 = require("yaml");
+const storage_js_1 = require("../storage.js");
+const migrate_js_1 = require("./migrate.js");
+const memory_js_1 = require("./models/memory.js");
+const DEFAULT_MAX_MEMORY_COUNT = 10;
+class DefaultMemoryStorage extends storage_js_1.MemoryStorage {
+    options;
+    constructor(options) {
+        super();
+        this.options = options;
+    }
+    _db;
+    async initSqlite() {
+        const db = (await (0, sqlite_1.initDatabase)({ url: this.options?.url }));
+        await (0, migrate_js_1.migrate)(db);
+        return db;
+    }
+    get db() {
+        this._db ??= this.initSqlite();
+        return this._db;
+    }
+    convertMemory(m) {
+        return {
+            id: m.id,
+            sessionId: m.sessionId,
+            content: m.content,
+            createdAt: m.createdAt.toISOString(),
+        };
+    }
+    async search(query, { context }) {
+        const { limit = DEFAULT_MAX_MEMORY_COUNT } = query;
+        const sessionId = (await this.options?.getSessionId?.(context)) ?? null;
+        const db = await this.db;
+        const memories = this.options?.enableFTS && query.search
+            ? await db
+                .select()
+                .from(memory_js_1.Memories)
+                .innerJoin((0, drizzle_orm_1.sql) `Memories_fts`, (0, drizzle_orm_1.sql) `Memories_fts.id = ${memory_js_1.Memories.id}`)
+                .where((0, drizzle_orm_1.sql) `Memories_fts MATCH ${drizzle_orm_1.sql.param(this.segment(query.search).join(" OR "))}`)
+                .orderBy((0, drizzle_orm_1.sql) `bm25(Memories_fts)`)
+                .limit(limit)
+                .execute()
+                .then((rows) => rows.map((row) => row.Memories))
+            : await db
+                .select()
+                .from(memory_js_1.Memories)
+                .where(sessionId ? (0, drizzle_orm_1.eq)(memory_js_1.Memories.sessionId, sessionId) : (0, drizzle_orm_1.isNull)(memory_js_1.Memories.sessionId))
+                .orderBy(query.orderBy
+                ? (query.orderBy[1] === "asc" ? drizzle_orm_1.asc : drizzle_orm_1.desc)(drizzle_orm_1.sql.identifier(query.orderBy[0]))
+                : (0, drizzle_orm_1.desc)(memory_js_1.Memories.id))
+                .limit(limit)
+                .execute();
+        return {
+            result: memories.map(this.convertMemory),
+        };
+    }
+    async create(memory, { context }) {
+        const sessionId = (await this.options?.getSessionId?.(context)) ?? null;
+        const db = await this.db;
+        const id = (0, uuid_1.v7)();
+        const [[result]] = await Promise.all([
+            db
+                .insert(memory_js_1.Memories)
+                .values({
+                ...memory,
+                id,
+                content: memory.content,
+                sessionId,
+            })
+                .returning()
+                .execute(),
+            this.options?.enableFTS &&
+                db.run((0, drizzle_orm_1.sql) `\
+          insert into Memories_fts (id, content)
+          values (${drizzle_orm_1.sql.param(id)}, ${drizzle_orm_1.sql.param(this.segment((0, yaml_1.stringify)(memory.content)).join(" "))})`),
+        ]);
+        if (!result)
+            throw new Error("Failed to create memory");
+        return { result: this.convertMemory(result) };
+    }
+    segment(str) {
+        return (Array.from(new Intl.Segmenter(undefined, { granularity: "word" }).segment(str))
+            .map((i) => i.segment)
+            // Remove non-alphanumeric characters and trim whitespace
+            .map((i) => i.replace(/[^\p{L}\p{N}\s]/gu, "").trim())
+            .filter(Boolean));
+    }
+}
+exports.DefaultMemoryStorage = DefaultMemoryStorage;

package/lib/cjs/default-memory-storage/migrate.d.ts

@@ -0,0 +1,3 @@
+import type { LibSQLDatabase } from "drizzle-orm/libsql";
+import type { SqliteRemoteDatabase } from "drizzle-orm/sqlite-proxy";
+export declare function migrate(db: LibSQLDatabase | SqliteRemoteDatabase): Promise<void>;

package/lib/cjs/default-memory-storage/migrate.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.migrate = migrate;
+const sql_1 = require("drizzle-orm/sql");
+const _001_init_js_1 = __importDefault(require("./migrations/001-init.js"));
+async function migrate(db) {
+    const migrations = [_001_init_js_1.default];
+    const migrationsTable = "__drizzle_migrations";
+    const migrationTableCreate = (0, sql_1.sql) `
+    CREATE TABLE IF NOT EXISTS ${sql_1.sql.identifier(migrationsTable)} (
+      id SERIAL PRIMARY KEY,
+      hash text NOT NULL
+    )
+  `;
+    await db.run(migrationTableCreate).execute();
+    const dbMigrations = await db
+        .values((0, sql_1.sql) `SELECT id, hash FROM ${sql_1.sql.identifier(migrationsTable)} ORDER BY id DESC LIMIT 1`)
+        .execute();
+    const lastDbMigration = dbMigrations[0];
+    const queriesToRun = [];
+    for (const migration of migrations) {
+        if (!lastDbMigration || lastDbMigration[1] < migration.hash) {
+            queriesToRun.push(...migration.sql, `INSERT INTO \`${migrationsTable}\` ("hash") VALUES('${migration.hash}')`);
+        }
+    }
+    for (const query of queriesToRun) {
+        await db.run(query).execute();
+    }
+}

package/lib/cjs/default-memory-storage/migrations/001-init.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    hash: string;
+    sql: string[];
+};
+export default _default;

package/lib/cjs/default-memory-storage/migrations/001-init.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    hash: "001-init",
+    sql: [
+        `\
+CREATE TABLE "Memories" (
+  "id" TEXT NOT NULL PRIMARY KEY,
+  "createdAt" DATETIME NOT NULL,
+  "updatedAt" DATETIME NOT NULL,
+  "sessionId" TEXT,
+  "content" JSON NOT NULL
+)
+`,
+        `\
+CREATE VIRTUAL TABLE "Memories_fts" USING fts5(
+  id UNINDEXED,
+  content
+)
+`,
+    ],
+};

package/lib/cjs/default-memory-storage/models/memory.d.ts

@@ -0,0 +1,102 @@
+export declare const Memories: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "Memories";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "id";
+            tableName: "Memories";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        createdAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "createdAt";
+            tableName: "Memories";
+            dataType: "custom";
+            columnType: "SQLiteCustomColumn";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            sqliteColumnBuilderBrand: "SQLiteCustomColumnBuilderBrand";
+        }>;
+        updatedAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "updatedAt";
+            tableName: "Memories";
+            dataType: "custom";
+            columnType: "SQLiteCustomColumn";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            sqliteColumnBuilderBrand: "SQLiteCustomColumnBuilderBrand";
+        }>;
+        sessionId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "sessionId";
+            tableName: "Memories";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        content: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "content";
+            tableName: "Memories";
+            dataType: "custom";
+            columnType: "SQLiteCustomColumn";
+            data: unknown;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            sqliteColumnBuilderBrand: "SQLiteCustomColumnBuilderBrand";
+        }>;
+    };
+    dialect: "sqlite";
+}>;

package/lib/cjs/default-memory-storage/models/memory.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Memories = void 0;
+const type_js_1 = require("@aigne/sqlite/type.js");
+const sqlite_core_1 = require("drizzle-orm/sqlite-core");
+const uuid_1 = require("uuid");
+exports.Memories = (0, sqlite_core_1.sqliteTable)("Memories", {
+    id: (0, sqlite_core_1.text)("id")
+        .notNull()
+        .primaryKey()
+        .$defaultFn(() => (0, uuid_1.v7)()),
+    createdAt: (0, type_js_1.datetime)("createdAt")
+        .notNull()
+        .$defaultFn(() => new Date()),
+    updatedAt: (0, type_js_1.datetime)("updatedAt")
+        .notNull()
+        .$defaultFn(() => new Date())
+        .$onUpdateFn(() => new Date()),
+    sessionId: (0, sqlite_core_1.text)("sessionId"),
+    content: (0, type_js_1.json)("content").notNull(),
+});

package/lib/cjs/index.d.ts

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

package/lib/cjs/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./default-memory-storage/index.js"), exports);
+__exportStar(require("./memory.js"), exports);
+__exportStar(require("./storage.js"), exports);

package/lib/cjs/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>;
+}