@getzep/zep-cloud 1.0.11 → 2.0.0-rc.1

package/dist/langchain/zep_memory.d.ts

@@ -1,78 +0,0 @@
-import { InputValues, MemoryVariables, OutputValues } from "@langchain/core/memory";
-import { BaseChatMemory, BaseChatMemoryInput } from "langchain/memory";
-import { ZepClient } from "../";
-export interface ZepMemoryInput extends BaseChatMemoryInput {
-    humanPrefix?: string;
-    aiPrefix?: string;
-    memoryKey?: string;
-    baseURL?: string;
-    sessionId: string;
-    apiKey: string;
-}
-/**
- * Class used to manage the memory of a chat session, including loading
- * and saving the chat history, and clearing the memory when needed. It
- * uses the ZepClient to interact with the Zep service for managing the
- * chat session's memory.
- * @example
- * ```typescript
- * const sessionId = randomUUID();
- *
- * // Initialize ZepMemory with session ID, base URL, and API key
- * const memory = new ZepMemory({
- *   sessionId,
- *   apiKey: "change_this_key",
- * });
- *
- * // Create a ChatOpenAI model instance with specific parameters
- * const model = new ChatOpenAI({
- *   modelName: "gpt-3.5-turbo",
- *   temperature: 0,
- * });
- *
- * // Create a ConversationChain with the model and memory
- * const chain = new ConversationChain({ llm: model, memory });
- *
- * // Example of calling the chain with an input
- * const res1 = await chain.call({ input: "Hi! I'm Jim." });
- * console.log({ res1 });
- *
- * // Follow-up call to the chain to demonstrate memory usage
- * const res2 = await chain.call({ input: "What did I just say my name was?" });
- * console.log({ res2 });
- *
- * // Output the session ID and the current state of memory
- * console.log("Session ID: ", sessionId);
- * console.log("Memory: ", await memory.loadMemoryVariables({}));
- *
- * ```
- */
-export declare class ZepMemory extends BaseChatMemory implements ZepMemoryInput {
-    humanPrefix: string;
-    aiPrefix: string;
-    memoryKey: string;
-    apiKey: string;
-    sessionId: string;
-    zepClient: ZepClient;
-    constructor(fields: ZepMemoryInput);
-    get memoryKeys(): string[];
-    /**
-     * Method that retrieves the chat history from the Zep service and formats
-     * it into a list of messages.
-     * @param values Input values for the method.
-     * @returns Promise that resolves with the chat history formatted into a list of messages.
-     */
-    loadMemoryVariables(values: InputValues): Promise<MemoryVariables>;
-    /**
-     * Method that saves the input and output messages to the Zep service.
-     * @param inputValues Input messages to be saved.
-     * @param outputValues Output messages to be saved.
-     * @returns Promise that resolves when the messages have been saved.
-     */
-    saveContext(inputValues: InputValues, outputValues: OutputValues): Promise<void>;
-    /**
-     * Method that deletes the chat history from the Zep service.
-     * @returns Promise that resolves when the chat history has been deleted.
-     */
-    clear(): Promise<void>;
-}

package/dist/langchain/zep_memory.js

@@ -1,174 +0,0 @@
-"use strict";
-/* eslint import/no-extraneous-dependencies: 0 */
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ZepMemory = void 0;
-const memory_1 = require("@langchain/core/memory");
-const memory_2 = require("langchain/memory");
-const __1 = require("../");
-const api_1 = require("../api");
-const utils_1 = require("./utils");
-/**
- * Class used to manage the memory of a chat session, including loading
- * and saving the chat history, and clearing the memory when needed. It
- * uses the ZepClient to interact with the Zep service for managing the
- * chat session's memory.
- * @example
- * ```typescript
- * const sessionId = randomUUID();
- *
- * // Initialize ZepMemory with session ID, base URL, and API key
- * const memory = new ZepMemory({
- *   sessionId,
- *   apiKey: "change_this_key",
- * });
- *
- * // Create a ChatOpenAI model instance with specific parameters
- * const model = new ChatOpenAI({
- *   modelName: "gpt-3.5-turbo",
- *   temperature: 0,
- * });
- *
- * // Create a ConversationChain with the model and memory
- * const chain = new ConversationChain({ llm: model, memory });
- *
- * // Example of calling the chain with an input
- * const res1 = await chain.call({ input: "Hi! I'm Jim." });
- * console.log({ res1 });
- *
- * // Follow-up call to the chain to demonstrate memory usage
- * const res2 = await chain.call({ input: "What did I just say my name was?" });
- * console.log({ res2 });
- *
- * // Output the session ID and the current state of memory
- * console.log("Session ID: ", sessionId);
- * console.log("Memory: ", await memory.loadMemoryVariables({}));
- *
- * ```
- */
-class ZepMemory extends memory_2.BaseChatMemory {
-    constructor(fields) {
-        var _a, _b, _c, _d;
-        super({
-            returnMessages: (_a = fields === null || fields === void 0 ? void 0 : fields.returnMessages) !== null && _a !== void 0 ? _a : false,
-            inputKey: fields === null || fields === void 0 ? void 0 : fields.inputKey,
-            outputKey: fields === null || fields === void 0 ? void 0 : fields.outputKey,
-        });
-        this.humanPrefix = "Human";
-        this.aiPrefix = "AI";
-        this.memoryKey = "history";
-        this.humanPrefix = (_b = fields.humanPrefix) !== null && _b !== void 0 ? _b : this.humanPrefix;
-        this.aiPrefix = (_c = fields.aiPrefix) !== null && _c !== void 0 ? _c : this.aiPrefix;
-        this.memoryKey = (_d = fields.memoryKey) !== null && _d !== void 0 ? _d : this.memoryKey;
-        this.apiKey = fields.apiKey;
-        this.sessionId = fields.sessionId;
-        this.zepClient = new __1.ZepClient({
-            environment: fields.baseURL,
-            apiKey: this.apiKey,
-        });
-    }
-    get memoryKeys() {
-        return [this.memoryKey];
-    }
-    /**
-     * Method that retrieves the chat history from the Zep service and formats
-     * it into a list of messages.
-     * @param values Input values for the method.
-     * @returns Promise that resolves with the chat history formatted into a list of messages.
-     */
-    loadMemoryVariables(values) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            // use either lastN provided by developer or undefined to use the
-            // server preset.
-            const memoryType = (_a = values.memoryType) !== null && _a !== void 0 ? _a : "perpetual";
-            let memory = null;
-            try {
-                memory = yield this.zepClient.memory.get(this.sessionId, {
-                    memoryType: memoryType,
-                });
-            }
-            catch (error) {
-                if (error instanceof api_1.NotFoundError) {
-                    return this.returnMessages ? { [this.memoryKey]: [] } : { [this.memoryKey]: "" };
-                }
-                throw error;
-            }
-            if (this.returnMessages) {
-                return {
-                    [this.memoryKey]: [(0, utils_1.condenseZepMemoryIntoHumanMessage)(memory)],
-                };
-            }
-            return {
-                [this.memoryKey]: (0, utils_1.condenseZepMemoryIntoHumanMessage)(memory).content,
-            };
-        });
-    }
-    /**
-     * Method that saves the input and output messages to the Zep service.
-     * @param inputValues Input messages to be saved.
-     * @param outputValues Output messages to be saved.
-     * @returns Promise that resolves when the messages have been saved.
-     */
-    saveContext(inputValues, outputValues) {
-        const _super = Object.create(null, {
-            saveContext: { get: () => super.saveContext }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            const input = (0, memory_1.getInputValue)(inputValues, this.inputKey);
-            const output = (0, memory_1.getOutputValue)(outputValues, this.outputKey);
-            // Add the new memory to the session using the ZepClient
-            if (this.sessionId) {
-                try {
-                    yield this.zepClient.memory.add(this.sessionId, {
-                        messages: [
-                            {
-                                role: this.humanPrefix,
-                                roleType: "user",
-                                content: `${input}`,
-                            },
-                            {
-                                role: this.aiPrefix,
-                                roleType: "assistant",
-                                content: `${output}`,
-                            },
-                        ],
-                    });
-                }
-                catch (error) {
-                    console.error("Error adding memory: ", error);
-                }
-            }
-            // Call the superclass's saveContext method
-            yield _super.saveContext.call(this, inputValues, outputValues);
-        });
-    }
-    /**
-     * Method that deletes the chat history from the Zep service.
-     * @returns Promise that resolves when the chat history has been deleted.
-     */
-    clear() {
-        const _super = Object.create(null, {
-            clear: { get: () => super.clear }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                yield this.zepClient.memory.delete(this.sessionId);
-            }
-            catch (error) {
-                console.error("Error deleting session: ", error);
-            }
-            // Clear the superclass's chat history
-            yield _super.clear.call(this);
-        });
-    }
-}
-exports.ZepMemory = ZepMemory;

package/dist/serialization/types/MemoryType.d.ts

@@ -1,10 +0,0 @@
-/**
- * This file was auto-generated by Fern from our API Definition.
- */
-import * as serializers from "../index";
-import * as Zep from "../../api/index";
-import * as core from "../../core";
-export declare const MemoryType: core.serialization.Schema<serializers.MemoryType.Raw, Zep.MemoryType>;
-export declare namespace MemoryType {
-    type Raw = "perpetual" | "summary_retriever" | "message_window";
-}

package/examples/langchain/message_history_example.ts

@@ -1,60 +0,0 @@
-import { ZepClient } from "../../src";
-import { ZepChatMessageHistory } from "../../src/langchain";
-import { ChatOpenAI } from "@langchain/openai";
-import { ChatPromptTemplate, MessagesPlaceholder } from "@langchain/core/prompts";
-import { RunnableWithMessageHistory } from "@langchain/core/runnables";
-import { ConsoleCallbackHandler } from "@langchain/core/tracers/console";
-
-async function main() {
-    const sessionId = process.env.ZEP_SESSION_ID;
-    if (!sessionId) {
-        throw new Error("ZEP_SESSION_ID not set");
-    }
-    const zepClient = new ZepClient({
-        apiKey: process.env.ZEP_API_KEY,
-    });
-
-    const prompt = ChatPromptTemplate.fromMessages([
-        ["system", "Answer the user's question below. Be polite and helpful:"],
-        new MessagesPlaceholder("history"),
-        ["human", "{question}"],
-    ]);
-
-    const chain = prompt
-        .pipe(
-            new ChatOpenAI({
-                temperature: 0.8,
-                modelName: "gpt-3.5-turbo-1106",
-            })
-        )
-        .withConfig({
-            callbacks: [new ConsoleCallbackHandler()],
-        });
-
-    const chainWithHistory = new RunnableWithMessageHistory({
-        runnable: chain,
-        getMessageHistory: (sessionId) =>
-            new ZepChatMessageHistory({
-                client: zepClient,
-                sessionId: sessionId,
-                memoryType: "perpetual",
-            }),
-        inputMessagesKey: "question",
-        historyMessagesKey: "history",
-    });
-
-    const result = await chainWithHistory.invoke(
-        {
-            question: "What did we talk about earlier?",
-        },
-        {
-            configurable: {
-                sessionId: sessionId,
-            },
-        }
-    );
-
-    console.log("result", result);
-}
-
-main();

package/examples/langchain/message_history_vector_store_example.ts

@@ -1,122 +0,0 @@
-import { ZepClient } from "../../src";
-import { ChatOpenAI } from "@langchain/openai";
-import { BasePromptTemplate, ChatPromptTemplate, MessagesPlaceholder, PromptTemplate } from "@langchain/core/prompts";
-import { ZepChatMessageHistory, ZepVectorStore } from "../../src/langchain";
-import { Document } from "@langchain/core/documents";
-import {
-    RunnableLambda,
-    RunnableMap,
-    RunnablePassthrough,
-    RunnableWithMessageHistory,
-} from "@langchain/core/runnables";
-import { StringOutputParser } from "@langchain/core/output_parsers";
-import { ConsoleCallbackHandler } from "@langchain/core/tracers/console";
-import { formatDocument } from "langchain/schema/prompt_template";
-
-const DEFAULT_DOCUMENT_PROMPT = PromptTemplate.fromTemplate("{pageContent}");
-interface ChainInput {
-    question: string;
-    sessionId: string;
-}
-async function combineDocuments(
-    docs: Document[],
-    documentPrompt: BasePromptTemplate = DEFAULT_DOCUMENT_PROMPT,
-    documentSeparator: string = "\n\n"
-) {
-    const docStrings: string[] = await Promise.all(
-        docs.map((doc) => {
-            return formatDocument(doc, documentPrompt);
-        })
-    );
-    return docStrings.join(documentSeparator);
-}
-async function main() {
-    const collectionName = process.env.ZEP_COLLECTION_NAME;
-    if (!collectionName) {
-        throw new Error("ZEP_COLLECTION_NAME is required");
-    }
-    const sessionId = process.env.ZEP_SESSION_ID;
-    if (!sessionId) {
-        throw new Error("ZEP_SESSION_ID is required");
-    }
-    const zepClient = new ZepClient({
-        apiKey: process.env.ZEP_API_KEY,
-    });
-
-    const vectorStore = await ZepVectorStore.init({
-        client: zepClient,
-        collectionName: collectionName,
-    });
-
-    const prompt = ChatPromptTemplate.fromMessages([
-        ["system", `Answer the question based only on the following context: {context}`],
-        new MessagesPlaceholder("history"),
-        ["human", "{question}"],
-    ]);
-
-    const model = new ChatOpenAI({
-        temperature: 0.8,
-        modelName: "gpt-3.5-turbo-1106",
-    });
-    const retriever = vectorStore.asRetriever();
-    const searchQuery = new RunnableLambda({
-        func: async (input: any) => {
-            const { question } = await zepClient.memory.synthesizeQuestion(input.session_id);
-            return question;
-        },
-    });
-    const retrieverLambda = new RunnableLambda({
-        func: async (question: string) => {
-            const response = await retriever.invoke(question);
-            return combineDocuments(response);
-        },
-    });
-    const setupAndRetrieval = RunnableMap.from({
-        context: searchQuery.pipe(retrieverLambda),
-        question: (x: any) => x.question,
-        history: (x: any) => x.history,
-    });
-    const outputParser = new StringOutputParser();
-
-    const ragChain = setupAndRetrieval.pipe(prompt).pipe(model).pipe(outputParser);
-
-    const invokeChain = (chainInput: ChainInput) => {
-        const chainWithHistory = new RunnableWithMessageHistory({
-            runnable: RunnablePassthrough.assign({
-                session_id: () => chainInput.sessionId,
-            }).pipe(ragChain),
-            getMessageHistory: (sessionId) =>
-                new ZepChatMessageHistory({
-                    client: zepClient,
-                    sessionId: sessionId,
-                    memoryType: "perpetual",
-                }),
-            inputMessagesKey: "question",
-            historyMessagesKey: "history",
-        });
-
-        return chainWithHistory.invoke(
-            { question: chainInput.question },
-            {
-                configurable: {
-                    sessionId: chainInput.sessionId,
-                },
-            }
-        );
-    };
-
-    const chain = new RunnableLambda({
-        func: invokeChain,
-    }).withConfig({
-        callbacks: [new ConsoleCallbackHandler()],
-    });
-
-    const result = await chain.invoke({
-        question: "Project Gutenberg?",
-        sessionId: sessionId,
-    });
-
-    console.log("result", result);
-}
-
-main();

package/examples/langchain/vector_store_example.ts

@@ -1,71 +0,0 @@
-import { ZepClient } from "../../src";
-import { ChatOpenAI } from "@langchain/openai";
-import { BasePromptTemplate, ChatPromptTemplate, PromptTemplate } from "@langchain/core/prompts";
-import { ZepVectorStore } from "../../src/langchain";
-import { Document } from "@langchain/core/documents";
-import { RunnableMap, RunnableLambda, RunnablePassthrough } from "@langchain/core/runnables";
-import { StringOutputParser } from "@langchain/core/output_parsers";
-import { ConsoleCallbackHandler } from "@langchain/core/tracers/console";
-import { formatDocument } from "langchain/schema/prompt_template";
-
-const DEFAULT_DOCUMENT_PROMPT = PromptTemplate.fromTemplate("{pageContent}");
-
-async function combineDocuments(
-    docs: Document[],
-    documentPrompt: BasePromptTemplate = DEFAULT_DOCUMENT_PROMPT,
-    documentSeparator: string = "\n\n"
-) {
-    const docStrings: string[] = await Promise.all(
-        docs.map((doc) => {
-            return formatDocument(doc, documentPrompt);
-        })
-    );
-    return docStrings.join(documentSeparator);
-}
-async function main() {
-    const collectionName = process.env.ZEP_COLLECTION_NAME;
-    if (!collectionName) {
-        throw new Error("ZEP_COLLECTION_NAME is required");
-    }
-    const zepClient = new ZepClient({
-        apiKey: process.env.ZEP_API_KEY,
-    });
-
-    const vectorStore = await ZepVectorStore.init({
-        client: zepClient,
-        collectionName: collectionName,
-    });
-
-    const prompt = ChatPromptTemplate.fromMessages([
-        ["system", `Answer the question based only on the following context: {context}`],
-        ["human", "{question}"],
-    ]);
-
-    const model = new ChatOpenAI({
-        temperature: 0.8,
-        modelName: "gpt-3.5-turbo-1106",
-    });
-    const retriever = vectorStore.asRetriever();
-
-    const setupAndRetrieval = RunnableMap.from({
-        context: new RunnableLambda({
-            func: (input: string) => retriever.invoke(input).then(combineDocuments),
-        }),
-        question: new RunnablePassthrough(),
-    });
-    const outputParser = new StringOutputParser();
-
-    const chain = setupAndRetrieval
-        .pipe(prompt)
-        .pipe(model)
-        .pipe(outputParser)
-        .withConfig({
-            callbacks: [new ConsoleCallbackHandler()],
-        });
-
-    const result = await chain.invoke("Project Gutenberg?");
-
-    console.log("result", result);
-}
-
-main();

package/langchain/index.d.ts

@@ -1,3 +0,0 @@
-export * from "./message_history";
-export * from "./vector_store";
-export * from "./zep_memory";

package/langchain/message_history.d.ts

@@ -1,39 +0,0 @@
-import { BaseMessage } from "@langchain/core/messages";
-import { BaseChatMessageHistory } from "@langchain/core/chat_history";
-import { ZepClient } from "../";
-import { Zep } from "../";
-/**
- * Interface defining the structure of the input data for the ZepMemory
- * class. It includes properties like humanPrefix, aiPrefix, memoryKey,
- * baseURL, sessionId, and apiKey.
- */
-interface ZepMemoryInput {
-    sessionId: string;
-    client: ZepClient;
-    memoryType: Zep.MemoryType;
-    humanPrefix?: string;
-    aiPrefix?: string;
-}
-/**
- * Class used to manage the memory of a chat session, including loading
- * and saving the chat history, and clearing the memory when needed. It
- * uses the ZepClient to interact with the Zep service for managing the
- * chat session's memory.
- *
- */
-export declare class ZepChatMessageHistory extends BaseChatMessageHistory implements ZepMemoryInput {
-    lc_namespace: string[];
-    sessionId: string;
-    client: ZepClient;
-    memoryType: Zep.MemoryType;
-    humanPrefix: string;
-    aiPrefix: string;
-    constructor(fields: ZepMemoryInput);
-    private getMemory;
-    getMessages(): Promise<BaseMessage[]>;
-    addAIChatMessage(message: string, metadata?: any): Promise<void>;
-    addMessage(message: BaseMessage, metadata?: any): Promise<void>;
-    addUserMessage(message: string, metadata?: any): Promise<void>;
-    clear(): Promise<void>;
-}
-export {};

package/langchain/message_history.js

@@ -1,109 +0,0 @@
-"use strict";
-/* eslint import/no-extraneous-dependencies: 0 */
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ZepChatMessageHistory = void 0;
-const messages_1 = require("@langchain/core/messages");
-const chat_history_1 = require("@langchain/core/chat_history");
-const api_1 = require("../api");
-const utils_1 = require("./utils");
-/**
- * Class used to manage the memory of a chat session, including loading
- * and saving the chat history, and clearing the memory when needed. It
- * uses the ZepClient to interact with the Zep service for managing the
- * chat session's memory.
- *
- */
-class ZepChatMessageHistory extends chat_history_1.BaseChatMessageHistory {
-    constructor(fields) {
-        super();
-        this.lc_namespace = [];
-        this.humanPrefix = "human";
-        this.aiPrefix = "ai";
-        this.sessionId = fields.sessionId;
-        this.memoryType = fields.memoryType;
-        this.client = fields.client;
-        if (fields.humanPrefix) {
-            this.humanPrefix = fields.humanPrefix;
-        }
-        if (fields.aiPrefix) {
-            this.aiPrefix = fields.aiPrefix;
-        }
-    }
-    getMemory() {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                return this.client.memory.get(this.sessionId, { memoryType: this.memoryType });
-            }
-            catch (error) {
-                if (error instanceof api_1.NotFoundError) {
-                    console.warn(`Session ${this.sessionId} not found in Zep. Returning None`);
-                }
-                else {
-                    console.error("Error getting memory: ", error);
-                }
-                return null;
-            }
-        });
-    }
-    getMessages() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const memory = yield this.getMemory();
-            if (!memory) {
-                return [];
-            }
-            return [(0, utils_1.condenseZepMemoryIntoHumanMessage)(memory)];
-        });
-    }
-    addAIChatMessage(message, metadata) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.addMessage(new messages_1.AIMessage({ content: message }), metadata);
-        });
-    }
-    addMessage(message, metadata) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            const messageToSave = message;
-            if (message._getType() === "ai") {
-                messageToSave.name = this.aiPrefix;
-            }
-            else if (message._getType() === "human") {
-                messageToSave.name = this.humanPrefix;
-            }
-            if (message.content === null) {
-                throw new Error("Message content cannot be null");
-            }
-            if (Array.isArray(message.content)) {
-                throw new Error("Message content cannot be a list");
-            }
-            yield this.client.memory.add(this.sessionId, {
-                messages: [
-                    {
-                        content: message.content,
-                        role: (_a = message.name) !== null && _a !== void 0 ? _a : message._getType(),
-                        roleType: (0, utils_1.getZepMessageRoleType)(message._getType()),
-                        metadata,
-                    },
-                ],
-            });
-        });
-    }
-    addUserMessage(message, metadata) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.addMessage(new messages_1.HumanMessage({ content: message }, metadata));
-        });
-    }
-    clear() {
-        console.warn("Clearing memory", this.sessionId);
-        return Promise.resolve(undefined);
-    }
-}
-exports.ZepChatMessageHistory = ZepChatMessageHistory;

package/langchain/utils.d.ts

@@ -1,4 +0,0 @@
-import { HumanMessage, MessageType } from "@langchain/core/messages";
-import { Memory, RoleType } from "../api";
-export declare const getZepMessageRoleType: (role: MessageType) => RoleType;
-export declare const condenseZepMemoryIntoHumanMessage: (memory: Memory) => HumanMessage;