@getzep/zep-cloud 0.0.1-rc.1

package/esm/errors.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Unified error class for all Zep errors.
+ */
+export declare class ZepError extends Error {
+    code?: number;
+    responseData?: any;
+    /**
+     * Constructs a new ZepError instance.
+     * @param {string} message - The error message.
+     * @param {number} [code] - Optional error code associated with the error.
+     * @param {any} [responseData] - Optional response associated with the error.
+     */
+    constructor(message: string, code?: number, responseData?: any);
+}
+/**
+ * Custom error class for unexpected API response errors.
+ */
+export declare class APIError extends ZepError {
+}
+/**
+ * Custom error class for not found errors.
+ */
+export declare class NotFoundError extends ZepError {
+}
+/**
+ * Custom error class for authentication errors.
+ */
+export declare class AuthenticationError extends ZepError {
+}

package/esm/errors.js

@@ -0,0 +1,32 @@
+/**
+ * Unified error class for all Zep errors.
+ */
+export class ZepError extends Error {
+    /**
+     * Constructs a new ZepError instance.
+     * @param {string} message - The error message.
+     * @param {number} [code] - Optional error code associated with the error.
+     * @param {any} [responseData] - Optional response associated with the error.
+     */
+    constructor(message, code, responseData) {
+        super(message);
+        this.name = this.constructor.name;
+        this.code = code;
+        this.responseData = responseData;
+    }
+}
+/**
+ * Custom error class for unexpected API response errors.
+ */
+export class APIError extends ZepError {
+}
+/**
+ * Custom error class for not found errors.
+ */
+export class NotFoundError extends ZepError {
+}
+/**
+ * Custom error class for authentication errors.
+ */
+export class AuthenticationError extends ZepError {
+}

package/esm/index.d.ts

@@ -0,0 +1,13 @@
+import MemoryManager from "./memory_manager";
+import MessageManager from "./message_manager";
+import ZepClient from "./zep-client";
+import DocumentManager from "./document_manager";
+import DocumentCollection from "./document_collection";
+import UserManager from "./user_manager";
+export { MemoryManager, MessageManager, ZepClient, DocumentManager, DocumentCollection, UserManager, };
+export { User, IUser, CreateUserRequest, UpdateUserRequest, ICreateUserRequest, IUpdateUserRequest, } from "./user_models";
+export { Document, IDocument, IDocumentCollectionModel, DocumentCollectionModel, } from "./document_models";
+export { Memory, Summary, ISummary, IMemory, MemorySearchPayload, IMemorySearchPayload, MemorySearchResult, IMemorySearchResult, Session, ISession, } from "./memory_models";
+export { Message, IMessage } from "./message_models";
+export { IAddCollectionParams, IUpdateCollectionParams, IUpdateDocumentParams, ISearchQuery, } from "./interfaces";
+export { APIError, NotFoundError, AuthenticationError } from "./errors";

package/esm/index.js

@@ -0,0 +1,12 @@
+import MemoryManager from "./memory_manager";
+import MessageManager from "./message_manager";
+import ZepClient from "./zep-client";
+import DocumentManager from "./document_manager";
+import DocumentCollection from "./document_collection";
+import UserManager from "./user_manager";
+export { MemoryManager, MessageManager, ZepClient, DocumentManager, DocumentCollection, UserManager, };
+export { User, CreateUserRequest, UpdateUserRequest, } from "./user_models";
+export { Document, DocumentCollectionModel, } from "./document_models";
+export { Memory, Summary, MemorySearchPayload, MemorySearchResult, Session, } from "./memory_models";
+export { Message } from "./message_models";
+export { APIError, NotFoundError, AuthenticationError } from "./errors";

package/esm/interfaces.d.ts

@@ -0,0 +1,28 @@
+export interface IZepClient {
+    baseURL: string;
+    headers: any;
+    getFullUrl(endpoint: string): string;
+}
+export interface IAddCollectionParams {
+    name: string;
+    description?: string;
+    metadata?: Record<string, any>;
+}
+export interface IUpdateCollectionParams {
+    name: string;
+    description?: string;
+    metadata?: Record<string, any>;
+}
+export interface IUpdateDocumentParams {
+    uuid: string;
+    documentId: string;
+    metadata?: Record<string, any>;
+}
+export interface ISearchQuery {
+    text?: string;
+    metadata?: Record<string, any>;
+    embedding?: Float32Array;
+    searchType?: "similarity" | "mmr";
+    mmrLambda?: number;
+}
+export type MemoryType = "perpetual" | "message_window" | "summary_retriever";

package/esm/interfaces.js

@@ -0,0 +1 @@
+export {};

package/esm/langchain/base_memory.d.ts

@@ -0,0 +1,58 @@
+import { BaseMemory, InputValues, OutputValues } from "@langchain/core/memory";
+import { BaseChatMessageHistory, BaseListChatMessageHistory } from "@langchain/core/chat_history";
+import { BaseMessage } from "@langchain/core/messages";
+/**
+ * Class for storing chat message history in-memory. It extends the
+ * BaseListChatMessageHistory class and provides methods to get, add, and
+ * clear messages.
+ */
+export declare class ChatMessageHistory extends BaseListChatMessageHistory {
+    lc_namespace: string[];
+    private messages;
+    constructor(messages?: BaseMessage[]);
+    /**
+     * Method to get all the messages stored in the ChatMessageHistory
+     * instance.
+     * @returns Array of stored BaseMessage instances.
+     */
+    getMessages(): Promise<BaseMessage[]>;
+    /**
+     * Method to add a new message to the ChatMessageHistory instance.
+     * @param message The BaseMessage instance to add.
+     * @returns A promise that resolves when the message has been added.
+     */
+    addMessage(message: BaseMessage): Promise<void>;
+    /**
+     * Method to clear all the messages from the ChatMessageHistory instance.
+     * @returns A promise that resolves when all messages have been cleared.
+     */
+    clear(): Promise<void>;
+}
+/**
+ * Interface for the input parameters of the BaseChatMemory class.
+ */
+export interface BaseChatMemoryInput {
+    chatHistory?: BaseChatMessageHistory;
+    returnMessages?: boolean;
+    inputKey?: string;
+    outputKey?: string;
+}
+export declare abstract class BaseChatMemory extends BaseMemory {
+    chatHistory: BaseChatMessageHistory;
+    returnMessages: boolean;
+    inputKey?: string;
+    outputKey?: string;
+    constructor(fields?: BaseChatMemoryInput);
+    /**
+     * Method to add user and AI messages to the chat history in sequence.
+     * @param inputValues The input values from the user.
+     * @param outputValues The output values from the AI.
+     * @returns Promise that resolves when the context has been saved.
+     */
+    saveContext(inputValues: InputValues, outputValues: OutputValues): Promise<void>;
+    /**
+     * Method to clear the chat history.
+     * @returns Promise that resolves when the chat history has been cleared.
+     */
+    clear(): Promise<void>;
+}

package/esm/langchain/base_memory.js

@@ -0,0 +1,87 @@
+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());
+    });
+};
+import { BaseMemory, getInputValue, getOutputValue, } from "@langchain/core/memory";
+import { BaseListChatMessageHistory, } from "@langchain/core/chat_history";
+/**
+ * Class for storing chat message history in-memory. It extends the
+ * BaseListChatMessageHistory class and provides methods to get, add, and
+ * clear messages.
+ */
+export class ChatMessageHistory extends BaseListChatMessageHistory {
+    constructor(messages) {
+        // eslint-disable-next-line prefer-rest-params
+        super(...arguments);
+        this.lc_namespace = ["langchain", "stores", "message", "in_memory"];
+        this.messages = [];
+        this.messages = messages !== null && messages !== void 0 ? messages : [];
+    }
+    /**
+     * Method to get all the messages stored in the ChatMessageHistory
+     * instance.
+     * @returns Array of stored BaseMessage instances.
+     */
+    getMessages() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.messages;
+        });
+    }
+    /**
+     * Method to add a new message to the ChatMessageHistory instance.
+     * @param message The BaseMessage instance to add.
+     * @returns A promise that resolves when the message has been added.
+     */
+    addMessage(message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.messages.push(message);
+        });
+    }
+    /**
+     * Method to clear all the messages from the ChatMessageHistory instance.
+     * @returns A promise that resolves when all messages have been cleared.
+     */
+    clear() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.messages = [];
+        });
+    }
+}
+export class BaseChatMemory extends BaseMemory {
+    constructor(fields) {
+        var _a, _b, _c, _d;
+        super();
+        this.returnMessages = false;
+        this.chatHistory = (_a = fields === null || fields === void 0 ? void 0 : fields.chatHistory) !== null && _a !== void 0 ? _a : new ChatMessageHistory();
+        this.returnMessages = (_b = fields === null || fields === void 0 ? void 0 : fields.returnMessages) !== null && _b !== void 0 ? _b : this.returnMessages;
+        this.inputKey = (_c = fields === null || fields === void 0 ? void 0 : fields.inputKey) !== null && _c !== void 0 ? _c : this.inputKey;
+        this.outputKey = (_d = fields === null || fields === void 0 ? void 0 : fields.outputKey) !== null && _d !== void 0 ? _d : this.outputKey;
+    }
+    /**
+     * Method to add user and AI messages to the chat history in sequence.
+     * @param inputValues The input values from the user.
+     * @param outputValues The output values from the AI.
+     * @returns Promise that resolves when the context has been saved.
+     */
+    saveContext(inputValues, outputValues) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // this is purposefully done in sequence so they're saved in order
+            yield this.chatHistory.addUserMessage(getInputValue(inputValues, this.inputKey));
+            yield this.chatHistory.addAIChatMessage(getOutputValue(outputValues, this.outputKey));
+        });
+    }
+    /**
+     * Method to clear the chat history.
+     * @returns Promise that resolves when the chat history has been cleared.
+     */
+    clear() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.chatHistory.clear();
+        });
+    }
+}

package/esm/langchain/index.d.ts

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

package/esm/langchain/index.js

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

package/esm/langchain/memory/chat_memory.d.ts

@@ -0,0 +1,38 @@
+import { BaseMemory, InputValues, OutputValues } from "@langchain/core/memory";
+import { ZepChatMessageHistory } from "../message_history";
+import ZepClient from "../../zep-client";
+/**
+ * Interface for the input parameters of the BaseChatMemory class.
+ */
+export interface BaseChatMemoryInput {
+    chatHistory: ZepChatMessageHistory;
+    returnMessages?: boolean;
+    inputKey?: string;
+    outputKey?: string;
+    client: ZepClient;
+}
+/**
+ * Abstract class that provides a base for implementing different types of
+ * memory systems. It is designed to maintain the state of an application,
+ * specifically the history of a conversation. This class is typically
+ * extended by other classes to create specific types of memory systems.
+ */
+export declare abstract class BaseChatMemory extends BaseMemory {
+    chatHistory: ZepChatMessageHistory;
+    returnMessages: boolean;
+    inputKey?: string;
+    outputKey?: string;
+    protected constructor(fields: BaseChatMemoryInput);
+    /**
+     * Method to add user and AI messages to the chat history in sequence.
+     * @param inputValues The input values from the user.
+     * @param outputValues The output values from the AI.
+     * @returns Promise that resolves when the context has been saved.
+     */
+    saveContext(inputValues: InputValues, outputValues: OutputValues): Promise<void>;
+    /**
+     * Method to clear the chat history.
+     * @returns Promise that resolves when the chat history has been cleared.
+     */
+    clear(): Promise<void>;
+}

package/esm/langchain/memory/chat_memory.js

@@ -0,0 +1,49 @@
+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());
+    });
+};
+import { BaseMemory, getInputValue, getOutputValue, } from "@langchain/core/memory";
+/**
+ * Abstract class that provides a base for implementing different types of
+ * memory systems. It is designed to maintain the state of an application,
+ * specifically the history of a conversation. This class is typically
+ * extended by other classes to create specific types of memory systems.
+ */
+export class BaseChatMemory extends BaseMemory {
+    constructor(fields) {
+        var _a, _b, _c;
+        super();
+        this.returnMessages = false;
+        this.chatHistory = fields.chatHistory;
+        this.returnMessages = (_a = fields === null || fields === void 0 ? void 0 : fields.returnMessages) !== null && _a !== void 0 ? _a : this.returnMessages;
+        this.inputKey = (_b = fields === null || fields === void 0 ? void 0 : fields.inputKey) !== null && _b !== void 0 ? _b : this.inputKey;
+        this.outputKey = (_c = fields === null || fields === void 0 ? void 0 : fields.outputKey) !== null && _c !== void 0 ? _c : this.outputKey;
+    }
+    /**
+     * Method to add user and AI messages to the chat history in sequence.
+     * @param inputValues The input values from the user.
+     * @param outputValues The output values from the AI.
+     * @returns Promise that resolves when the context has been saved.
+     */
+    saveContext(inputValues, outputValues) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // this is purposefully done in sequence so they're saved in order
+            yield this.chatHistory.addUserMessage(getInputValue(inputValues, this.inputKey));
+            yield this.chatHistory.addAIChatMessage(getOutputValue(outputValues, this.outputKey));
+        });
+    }
+    /**
+     * Method to clear the chat history.
+     * @returns Promise that resolves when the chat history has been cleared.
+     */
+    clear() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.chatHistory.clear();
+        });
+    }
+}

package/esm/langchain/memory/index.d.ts

@@ -0,0 +1,84 @@
+import { InputValues, MemoryVariables, OutputValues } from "@langchain/core/memory";
+import { BaseChatMemory, BaseChatMemoryInput } from "./chat_memory";
+import ZepClient from "../../zep-client";
+/**
+ * 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 extends BaseChatMemoryInput {
+    memoryKey?: string;
+    sessionId: string;
+    client: ZepClient;
+    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.
+ * @example
+ * ```typescript
+ * const sessionId = randomUUID();
+ * const zepURL = "http://your-zep-url";
+ *
+ * // Initialize ZepMemory with session ID, base URL, and API key
+ * const memory = new ZepMemory({
+ *   sessionId,
+ *   baseURL: zepURL,
+ *   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;
+    sessionId: string;
+    client: 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>;
+}
+export {};

package/esm/langchain/memory/index.js

@@ -0,0 +1,192 @@
+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());
+    });
+};
+import { getInputValue, getOutputValue, } from "@langchain/core/memory";
+import { AIMessage, ChatMessage, getBufferString, HumanMessage, SystemMessage, } from "@langchain/core/messages";
+import { BaseChatMemory } from "./chat_memory";
+import { Memory } from "../../memory_models";
+import { NotFoundError } from "../../errors";
+import { Message } from "../../message_models";
+import { ZepChatMessageHistory } from "../message_history";
+/**
+ * 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();
+ * const zepURL = "http://your-zep-url";
+ *
+ * // Initialize ZepMemory with session ID, base URL, and API key
+ * const memory = new ZepMemory({
+ *   sessionId,
+ *   baseURL: zepURL,
+ *   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 class ZepMemory extends 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,
+            client: fields.client,
+            chatHistory: new ZepChatMessageHistory({
+                sessionId: fields.sessionId,
+                client: fields.client,
+                memoryType: "perpetual",
+            }),
+        });
+        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.sessionId = fields.sessionId;
+        this.client = fields.client;
+    }
+    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, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            // use either lastN provided by developer or undefined to use the
+            // server preset.
+            // Wait for ZepClient to be initialized
+            const lastN = (_a = values.lastN) !== null && _a !== void 0 ? _a : undefined;
+            let memory = null;
+            try {
+                memory = yield this.client.memory.getMemory(this.sessionId, lastN);
+            }
+            catch (error) {
+                if (error instanceof NotFoundError) {
+                    return this.returnMessages
+                        ? { [this.memoryKey]: [] }
+                        : { [this.memoryKey]: "" };
+                }
+                throw error;
+            }
+            let messages = memory && ((_b = memory.summary) === null || _b === void 0 ? void 0 : _b.content)
+                ? [new SystemMessage(memory.summary.content)]
+                : [];
+            if (memory) {
+                messages = messages.concat(memory.messages.map((message) => {
+                    const { content, role } = message;
+                    if (role === this.humanPrefix) {
+                        return new HumanMessage(content);
+                    }
+                    if (role === this.aiPrefix) {
+                        return new AIMessage(content);
+                    }
+                    // default to generic ChatMessage
+                    return new ChatMessage(content, role);
+                }));
+            }
+            if (this.returnMessages) {
+                return {
+                    [this.memoryKey]: messages,
+                };
+            }
+            return {
+                [this.memoryKey]: getBufferString(messages, this.humanPrefix, this.aiPrefix),
+            };
+        });
+    }
+    /**
+     * 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 = getInputValue(inputValues, this.inputKey);
+            const output = getOutputValue(outputValues, this.outputKey);
+            // Create new Memory and Message instances
+            const memory = new Memory({
+                messages: [
+                    new Message({
+                        role: this.humanPrefix,
+                        content: `${input}`,
+                    }),
+                    new Message({
+                        role: this.aiPrefix,
+                        content: `${output}`,
+                    }),
+                ],
+            });
+            // Add the new memory to the session using the ZepClient
+            if (this.sessionId) {
+                try {
+                    yield this.client.memory.addMemory(this.sessionId, memory);
+                }
+                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.client.memory.deleteMemory(this.sessionId);
+            }
+            catch (error) {
+                console.error("Error deleting session: ", error);
+            }
+            // Clear the superclass's chat history
+            yield _super.clear.call(this);
+        });
+    }
+}