@aigne/agent-library 1.20.4 → 1.21.0

package/lib/esm/default-memory/index.js

@@ -1,126 +0,0 @@
-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/default-memory/storage.d.ts

@@ -1,13 +0,0 @@
-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/default-memory/storage.js

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

package/lib/esm/fs-memory/index.d.ts

@@ -1,59 +0,0 @@
-import { type AIAgentOptions, type Message } from "@aigne/core";
-import { MemoryAgent, type MemoryAgentOptions, type MemoryRecorderInput, type MemoryRetrieverInput } from "@aigne/core/memory/index.js";
-export declare const MEMORY_FILE_NAME = "memory.yaml";
-/**
- * Configuration options for the FSMemory class.
- */
-export interface FSMemoryOptions extends Partial<MemoryAgentOptions> {
-    /**
-     * The root directory where memory files will be stored.
-     * Can be absolute or relative path. Relative paths are resolved from the current working directory.
-     * Home directory prefix (~) will be expanded appropriately.
-     */
-    rootDir: string;
-    /**
-     * Optional configuration for the memory retriever agent.
-     * Controls how memories are retrieved from the file system.
-     */
-    retrieverOptions?: Partial<FSMemoryRetrieverOptions>;
-    /**
-     * Optional configuration for the memory recorder agent.
-     * Controls how memories are recorded to the file system.
-     */
-    recorderOptions?: Partial<FSMemoryRecorderOptions>;
-}
-/**
- * A memory implementation that stores and retrieves memories using the file system.
- * FSMemory provides persistent storage of agent memories as files in a specified directory.
- *
- * @example
- * Here is an example of how to use the FSMemory class:
- * {@includeCode ../../test/fs-memory/fs-memory.test.ts#example-fs-memory-simple}
- */
-export declare class FSMemory extends MemoryAgent {
-    /**
-     * Creates a new FSMemory instance.
-     */
-    constructor(options: FSMemoryOptions);
-}
-interface FSMemoryRetrieverOptions extends AIAgentOptions<FSMemoryRetrieverAgentInput, FSMemoryRetrieverAgentOutput> {
-    memoryFileName: string;
-}
-interface FSMemoryRetrieverAgentInput extends MemoryRetrieverInput {
-    allMemory: string;
-}
-interface FSMemoryRetrieverAgentOutput extends Message {
-    memories: {
-        content: string;
-    }[];
-}
-interface FSMemoryRecorderOptions extends AIAgentOptions<FSMemoryRecorderAgentInput, FSMemoryRecorderAgentOutput> {
-    memoryFileName: string;
-}
-type FSMemoryRecorderAgentInput = MemoryRecorderInput;
-interface FSMemoryRecorderAgentOutput extends Message {
-    memories: {
-        content: string;
-    }[];
-}
-export {};

package/lib/esm/fs-memory/index.js

@@ -1,180 +0,0 @@
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { dirname, isAbsolute, join, normalize, resolve } from "node:path";
-import { AIAgent } from "@aigne/core";
-import { MemoryAgent, MemoryRecorder, MemoryRetriever, newMemoryId, } from "@aigne/core/memory/index.js";
-import { stringify } from "yaml";
-import { z } from "zod";
-import { exists, expandHome } from "../utils/fs.js";
-export const MEMORY_FILE_NAME = "memory.yaml";
-/**
- * A memory implementation that stores and retrieves memories using the file system.
- * FSMemory provides persistent storage of agent memories as files in a specified directory.
- *
- * @example
- * Here is an example of how to use the FSMemory class:
- * {@includeCode ../../test/fs-memory/fs-memory.test.ts#example-fs-memory-simple}
- */
-export class FSMemory extends MemoryAgent {
-    /**
-     * Creates a new FSMemory instance.
-     */
-    constructor(options) {
-        let rootDir = normalize(expandHome(options.rootDir));
-        rootDir = isAbsolute(rootDir) ? rootDir : resolve(process.cwd(), rootDir);
-        const memoryFileName = join(rootDir, MEMORY_FILE_NAME);
-        super({
-            ...options,
-            recorder: options.recorder ??
-                new FSMemoryRecorder({
-                    memoryFileName,
-                    ...options.recorderOptions,
-                }),
-            retriever: options.retriever ??
-                new FSMemoryRetriever({
-                    memoryFileName,
-                    ...options.retrieverOptions,
-                }),
-            autoUpdate: options.autoUpdate ?? true,
-        });
-    }
-}
-class FSMemoryRetriever extends MemoryRetriever {
-    options;
-    constructor(options) {
-        super({});
-        this.options = options;
-        this.agent = AIAgent.from({
-            name: "fs_memory_retriever",
-            description: "Retrieves memories from the file or directory.",
-            ...options,
-            instructions: options.instructions || DEFAULT_FS_MEMORY_RETRIEVER_INSTRUCTIONS,
-            outputSchema: z.object({
-                memories: z
-                    .array(z.object({
-                    content: z.string().describe("Content of the memory"),
-                }))
-                    .describe("List of memories"),
-            }),
-        });
-    }
-    agent;
-    async process(input, options) {
-        if (!(await exists(this.options.memoryFileName)))
-            return { memories: [] };
-        const allMemory = await readFile(this.options.memoryFileName, "utf-8");
-        const { memories } = await options.context.invoke(this.agent, { ...input, allMemory });
-        const result = memories.map((memory) => ({
-            id: newMemoryId(),
-            content: memory.content,
-            createdAt: new Date().toISOString(),
-        }));
-        return { memories: result };
-    }
-}
-class FSMemoryRecorder extends MemoryRecorder {
-    options;
-    constructor(options) {
-        super({});
-        this.options = options;
-        this.agent = AIAgent.from({
-            name: "fs_memory_recorder",
-            description: "Records memories in files by AI agent",
-            ...options,
-            instructions: options.instructions || DEFAULT_FS_MEMORY_RECORDER_INSTRUCTIONS,
-            outputSchema: z.object({
-                memories: z
-                    .array(z.object({
-                    content: z.string().describe("Content of the memory"),
-                }))
-                    .describe("List of memories"),
-            }),
-        });
-    }
-    agent;
-    async process(input, options) {
-        const allMemory = (await exists(this.options.memoryFileName))
-            ? await readFile(this.options.memoryFileName, "utf-8")
-            : "";
-        const { memories } = await options.context.invoke(this.agent, { ...input, allMemory });
-        const raw = stringify(memories.map((i) => ({
-            content: i.content,
-        })));
-        await mkdir(dirname(this.options.memoryFileName), { recursive: true });
-        await writeFile(this.options.memoryFileName, raw, "utf-8");
-        return {
-            memories: memories.map((i) => ({
-                id: newMemoryId(),
-                content: i.content,
-                createdAt: new Date().toISOString(),
-            })),
-        };
-    }
-}
-const DEFAULT_FS_MEMORY_RECORDER_INSTRUCTIONS = `You manage memory based on conversation analysis and the existing memories.
-
-## IMPORTANT: All existing memories are available in the allMemory variable. DO NOT call any tools.
-
-## FIRST: Determine If Memory Updates Needed
-- Analyze if the conversation contains ANY information worth remembering
-- Examples of content NOT worth storing:
-  * General questions ("What's the weather?", "How do I do X?")
-  * Greetings and small talk ("Hello", "How are you?", "Thanks")
-  * System instructions or commands ("Show me", "Find", "Save")
-  * General facts not specific to the user
-  * Duplicate information already stored
-- If conversation lacks meaningful personal information to store:
-  * Return the existing memories unchanged
-
-## Your Workflow:
-1. Read the existing memories from the allMemory variable
-2. Extract key topics from the conversation
-3. DECIDE whether to create/update/delete memories based on the conversation
-4. Return ALL memories including your updates (remove any duplicates)
-
-## Memory Handling:
-- CREATE: Add new memory objects for new topics
-- UPDATE: Modify existing memories if substantial new information is available
-- DELETE: Remove obsolete memories when appropriate
-
-## Memory Structure:
-- Each memory has an id, content, and createdAt fields
-- Keep the existing structure when returning updated memories
-
-## Operation Decision Rules:
-- CREATE only for truly new topics not covered in any existing memory
-- UPDATE only when new information is meaningfully different
-- NEVER update for just rephrasing or minor differences
-- DELETE only when information becomes obsolete
-
-## IMPORTANT: Your job is to return the complete updated memory collection.
-Return ALL memories (existing and new) in your response.
-
-## Existing Memories:
-<existing-memory>
-{{allMemory}}
-</existing-memory>
-
-## Conversation:
-<conversation>
-{{content}}
-</conversation>
-`;
-const DEFAULT_FS_MEMORY_RETRIEVER_INSTRUCTIONS = `You retrieve only the most relevant memories for the current conversation.
-
-## IMPORTANT: All existing memories are available in the allMemory variable
-
-## Process:
-1. Read the existing memories from the allMemory variable
-2. Extract key topics from the conversation or search query
-3. Match memory contents against these topics
-
-## Existing Memories:
-<existing-memory>
-{{allMemory}}
-</existing-memory>
-
-## Search Query:
-<search-query>
-{{search}}
-</search-query>
-`;