memories-lite 0.9.0

package/dist/memory/index.js

@@ -0,0 +1,499 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoriesLite = void 0;
+const uuid_1 = require("uuid");
+const crypto_1 = require("crypto");
+const types_1 = require("../types");
+const factory_1 = require("../utils/factory");
+const prompts_1 = require("../prompts");
+const DummyHistoryManager_1 = require("../storage/DummyHistoryManager");
+const manager_1 = require("../config/manager");
+const memory_1 = require("../utils/memory");
+const telemetry_1 = require("../utils/telemetry");
+const lite_1 = require("../vectorstores/lite");
+const zod_1 = require("openai/helpers/zod");
+class MemoriesLite {
+    constructor(config = {}) {
+        // Merge and validate config
+        this.config = manager_1.ConfigManager.mergeConfig(config);
+        this.customPrompt = this.config.customPrompt;
+        this.embedder = factory_1.EmbedderFactory.create(this.config.embedder.provider, this.config.embedder.config);
+        //
+        // vectorStore.provider is "lite" 
+        this.vectorStoreConfig = this.config.vectorStore.config;
+        this.llm = factory_1.LLMFactory.create(this.config.llm.provider, this.config.llm.config);
+        if (this.config.disableHistory) {
+            this.db = new DummyHistoryManager_1.DummyHistoryManager();
+        }
+        else {
+            const defaultConfig = {
+                provider: "sqlite",
+                config: {
+                    historyDbPath: this.config.historyDbPath || ":memory:",
+                },
+            };
+            this.db =
+                this.config.historyStore && !this.config.disableHistory
+                    ? factory_1.HistoryManagerFactory.create(this.config.historyStore.provider, this.config.historyStore)
+                    : factory_1.HistoryManagerFactory.create("sqlite", defaultConfig);
+        }
+        this.collectionName = this.config.vectorStore.config.collectionName;
+        this.apiVersion = this.config.version || "v1.0";
+        this.enableGraph = this.config.enableGraph || false;
+        this.telemetryId = "anonymous";
+        // Initialize graph memory if configured
+        if (this.enableGraph && this.config.graphStore) {
+            // this.graphMemory = new MemoryGraph(this.config);
+        }
+        // Initialize telemetry if vector store is initialized
+        // this._initializeTelemetry();
+    }
+    async _initializeTelemetry() {
+        try {
+            await this._getTelemetryId();
+            // Capture initialization event
+            await (0, telemetry_1.captureClientEvent)("init", this, {
+                api_version: this.apiVersion,
+                client_type: "Memory",
+                collection_name: this.collectionName,
+                enable_graph: this.enableGraph,
+            });
+        }
+        catch (error) { }
+    }
+    async _getTelemetryId() {
+        try {
+            if (!this.telemetryId ||
+                this.telemetryId === "anonymous" ||
+                this.telemetryId === "anonymous-supabase") {
+                // this.telemetryId = await this.vectorStore.getUserId();
+                throw new Error("Telemetry ID not found");
+            }
+            return this.telemetryId;
+        }
+        catch (error) {
+            this.telemetryId = "anonymous";
+            return this.telemetryId;
+        }
+    }
+    async _captureEvent(methodName, additionalData = {}) {
+        try {
+            await this._getTelemetryId();
+            await (0, telemetry_1.captureClientEvent)(methodName, this, {
+                ...additionalData,
+                api_version: this.apiVersion,
+                collection_name: this.collectionName,
+            });
+        }
+        catch (error) {
+            console.error(`Failed to capture ${methodName} event:`, error);
+        }
+    }
+    $t(text) {
+        // return text.replace(/<thinking>[\s\S]*?(?:<\/thinking>)/g,'').replace(/^<step.*$/g,'');
+        return text.replace(/<thinking>[\s\S]*?<\/thinking>/g, '').replace(/^<step.*$/gm, '').replace(/<memories>[\s\S]*?<\/memories>/g, '');
+    }
+    async addToVectorStore(messages, metadata, userId, filters, customFacts) {
+        const $t = this.$t;
+        const vectorStore = await this.getVectorStore(userId);
+        const parsedMessages = messages.filter((m) => typeof m.content === 'string').map((m) => `${m.role == 'user' ? '**USER**: ' : '**ASSISTANT**: '}${$t(m.content)}\n`).join("\n");
+        const [systemPrompt, userPrompt] = (0, prompts_1.getFactRetrievalMessages)(parsedMessages, customFacts || this.customPrompt);
+        const response = await this.llm.generateResponse([
+            { role: "system", content: systemPrompt },
+            { role: "user", content: userPrompt },
+        ], { ...(0, zod_1.zodResponseFormat)(prompts_1.FactRetrievalSchema_extended, "FactRetrieval") }, [], false);
+        const parsedResponse = (response) => {
+            try {
+                // structured output
+                if (typeof response === 'object') {
+                    return response;
+                }
+                const cleanResponse = (0, prompts_1.removeCodeBlocks)(response);
+                return JSON.parse(cleanResponse);
+            }
+            catch (e) {
+                console.error("Failed to parse facts from LLM response:", response, e, response);
+                return [];
+            }
+        };
+        // 
+        // can use native structured output
+        const facts = parsedResponse(response).facts?.filter((f) => !f.existing) || [];
+        // console.log("-- DBG extract:", userPrompt);
+        // console.log("-- DBG facts:", facts);
+        // Get embeddings for new facts
+        const newMessageEmbeddings = {};
+        const retrievedOldMemory = [];
+        // Create embeddings and search for similar memories
+        for (const elem of facts) {
+            const fact = elem.fact;
+            const embedding = await this.embedder.embed(fact);
+            newMessageEmbeddings[fact] = embedding;
+            const existingMemories = await vectorStore.search(embedding, 5, filters);
+            for (const mem of existingMemories) {
+                retrievedOldMemory.push({ id: mem.id, text: mem.payload.data, type: mem.payload.type });
+            }
+        }
+        // console.log("-- DBG old memories:", retrievedOldMemory);
+        // Remove duplicates from old memories
+        const uniqueOldMemories = retrievedOldMemory.filter((mem, index) => retrievedOldMemory.findIndex((m) => m.id === mem.id) === index);
+        // Create UUID mapping for handling UUID hallucinations
+        const tempUuidMapping = {};
+        uniqueOldMemories.forEach((item, idx) => {
+            tempUuidMapping[String(idx)] = item.id;
+            uniqueOldMemories[idx].id = String(idx);
+        });
+        // Get memory update decisions
+        const updatePrompt = (0, prompts_1.getUpdateMemoryMessages)(uniqueOldMemories, facts);
+        const updateResponse = await this.llm.generateResponse([{ role: "user", content: updatePrompt }], { ...(0, zod_1.zodResponseFormat)(prompts_1.MemoryUpdateSchema, "Memory") }, [], false);
+        // console.log("-- DBG merge:", updatePrompt);
+        const memoryActions = parsedResponse(updateResponse).memory || [];
+        // Process memory actions
+        const results = [];
+        for (const action of memoryActions) {
+            if (action.reason === "undefined") {
+                console.log(`-- ⛔ LLM Error: ${action.event}, ${action.type}, "${action.text}"`);
+                continue;
+            }
+            console.log(`-- DBG memory action: ${action.event}, ${action.type}, "${action.text}", why: "${action.reason}"`);
+            try {
+                switch (action.event) {
+                    case "ADD": {
+                        if (!action.type) {
+                            // log error
+                            console.error("Type is mandatory to manage memories:", action);
+                            continue;
+                        }
+                        metadata.type = action.type;
+                        const memoryId = await this.createMemory(action.text, newMessageEmbeddings, metadata, userId);
+                        results.push({
+                            id: memoryId,
+                            memory: action.text,
+                            type: action.type,
+                            metadata: { event: action.event },
+                        });
+                        break;
+                    }
+                    case "UPDATE": {
+                        const realMemoryId = tempUuidMapping[action.id];
+                        const type = uniqueOldMemories[action.id].type;
+                        await this.updateMemory(realMemoryId, action.text, newMessageEmbeddings, metadata, userId);
+                        results.push({
+                            id: realMemoryId,
+                            memory: action.text,
+                            type,
+                            metadata: {
+                                event: action.event,
+                                previousMemory: action.old_memory,
+                            },
+                        });
+                        break;
+                    }
+                    case "DELETE": {
+                        const realMemoryId = tempUuidMapping[action.id];
+                        await this.deleteMemory(realMemoryId, userId);
+                        results.push({
+                            id: realMemoryId,
+                            memory: action.text,
+                            type: action.type,
+                            metadata: { event: action.event },
+                        });
+                        break;
+                    }
+                }
+            }
+            catch (error) {
+                console.error(`Error processing memory action: ${error}`);
+            }
+        }
+        return results;
+    }
+    static fromConfig(configDict) {
+        try {
+            const config = types_1.MemoryConfigSchema.parse(configDict);
+            return new MemoriesLite(config);
+        }
+        catch (e) {
+            console.error("Configuration validation error:", e);
+            throw e;
+        }
+    }
+    async getVectorStore(userId) {
+        return lite_1.LiteVectorStore.from(userId, this.vectorStoreConfig);
+    }
+    async capture(messages, userId, config) {
+        // await this._captureEvent("add", {
+        //   message_count: Array.isArray(messages) ? messages.length : 1,
+        //   has_metadata: !!config.metadata,
+        //   has_filters: !!config.filters,
+        //   infer: config.infer,
+        // });
+        const { agentId, runId, metadata = {}, filters = {}, infer = true, customFacts } = config;
+        if (agentId)
+            filters.agentId = metadata.agentId = agentId;
+        if (runId)
+            filters.runId = metadata.runId = runId;
+        if (!userId && !filters.agentId && !filters.runId) {
+            throw new Error("One of the filters: userId, agentId or runId is required!");
+        }
+        const parsedMessages = Array.isArray(messages)
+            ? messages
+            : [{ role: "user", content: messages }];
+        const final_parsedMessages = await (0, memory_1.parse_vision_messages)(parsedMessages);
+        // Add to vector store
+        const vectorStoreResult = await this.addToVectorStore(final_parsedMessages, metadata, userId, filters, customFacts);
+        // Add to graph store if available
+        let graphResult;
+        if (this.graphMemory) {
+            try {
+                graphResult = await this.graphMemory.add(final_parsedMessages.map((m) => m.content).join("\n"), filters);
+            }
+            catch (error) {
+                console.error("Error adding to graph memory:", error);
+            }
+        }
+        return {
+            results: vectorStoreResult,
+            relations: graphResult?.relations,
+        };
+    }
+    async get(memoryId, userId) {
+        const vectorStore = await this.getVectorStore(userId);
+        const memory = await vectorStore.get(memoryId);
+        if (!memory)
+            return null;
+        const filters = {
+            ...(memory.payload.agentId && { agentId: memory.payload.agentId }),
+            ...(memory.payload.runId && { runId: memory.payload.runId }),
+        };
+        const memoryItem = {
+            id: memory.id,
+            memory: memory.payload.data,
+            type: memory.payload.type,
+            hash: memory.payload.hash,
+            createdAt: memory.payload.createdAt,
+            updatedAt: memory.payload.updatedAt,
+            metadata: {},
+        };
+        // Add additional metadata
+        const excludedKeys = new Set([
+            "userId",
+            "agentId",
+            "runId",
+            "hash",
+            "data",
+            "createdAt",
+            "updatedAt",
+        ]);
+        for (const [key, value] of Object.entries(memory.payload)) {
+            if (!excludedKeys.has(key)) {
+                memoryItem.metadata[key] = value;
+            }
+        }
+        return { ...memoryItem, ...filters };
+    }
+    async retrieve(query, userId, config) {
+        // await this._captureEvent("search", {
+        //   query_length: query.length,
+        //   limit: config.limit,
+        //   has_filters: !!config.filters,
+        // });
+        const { agentId, runId, limit = 100, filters = {} } = config;
+        if (agentId)
+            filters.agentId = agentId;
+        if (runId)
+            filters.runId = runId;
+        if (!userId && !filters.agentId && !filters.runId) {
+            throw new Error("One of the filters: userId, agentId or runId is required!");
+        }
+        const vectorStore = await this.getVectorStore(userId);
+        // Search vector store
+        const queryEmbedding = await this.embedder.embed(query);
+        const memories = await vectorStore.search(queryEmbedding, limit, filters);
+        // Search graph store if available
+        let graphResults = [];
+        if (this.graphMemory) {
+            try {
+                graphResults = await this.graphMemory.search(query, filters);
+            }
+            catch (error) {
+                console.error("Error searching graph memory:", error);
+            }
+        }
+        const excludedKeys = new Set([
+            "userId",
+            "agentId",
+            "runId",
+            "hash",
+            "data",
+            "createdAt",
+            "updatedAt",
+        ]);
+        const results = memories.map((mem) => ({
+            id: mem.id,
+            memory: mem.payload.data,
+            hash: mem.payload.hash,
+            type: mem.payload.type,
+            createdAt: mem.payload.createdAt,
+            updatedAt: mem.payload.updatedAt,
+            score: mem.score,
+            metadata: Object.entries(mem.payload)
+                .filter(([key]) => !excludedKeys.has(key))
+                .reduce((acc, [key, value]) => ({ ...acc, [key]: value }), {}),
+            ...(mem.payload.agentId && { agentId: mem.payload.agentId }),
+            ...(mem.payload.runId && { runId: mem.payload.runId }),
+        }));
+        return {
+            results,
+            relations: graphResults,
+        };
+    }
+    async update(memoryId, data, userId) {
+        // await this._captureEvent("update", { memory_id: memoryId });
+        const embedding = await this.embedder.embed(data);
+        await this.updateMemory(memoryId, data, { [data]: embedding }, {}, userId);
+        return { message: "Memory updated successfully!" };
+    }
+    async delete(memoryId, userId) {
+        // await this._captureEvent("delete", { memory_id: memoryId });
+        await this.deleteMemory(memoryId, userId);
+        return { message: "Memory deleted successfully!" };
+    }
+    async deleteAll(userId, config) {
+        // await this._captureEvent("delete_all", {
+        //   has_user_id: !!config.userId,
+        //   has_agent_id: !!config.agentId,
+        //   has_run_id: !!config.runId,
+        // });
+        const { agentId, runId } = config;
+        if (!userId)
+            throw new Error("vector store instanceId is required");
+        const vectorStore = await this.getVectorStore(userId);
+        const filters = {};
+        if (agentId)
+            filters.agentId = agentId;
+        if (runId)
+            filters.runId = runId;
+        if (!Object.keys(filters).length) {
+            throw new Error("At least one filter is required to delete all memories. If you want to delete all memories, use the `reset()` method.");
+        }
+        const [memories] = await vectorStore.list(filters);
+        for (const memory of memories) {
+            await this.deleteMemory(memory.id, userId);
+        }
+        return { message: "Memories deleted successfully!" };
+    }
+    //
+    // DEPRECATED: history must be user specific
+    async history(memoryId) {
+        return this.db.getHistory(memoryId);
+    }
+    async reset(userId) {
+        // await this._captureEvent("reset");
+        const vectorStore = await this.getVectorStore(userId);
+        await this.db.reset();
+        // Check provider before attempting deleteCol
+        await vectorStore.deleteCol();
+        if (this.graphMemory) {
+            await this.graphMemory.deleteAll({ userId: "default" }); // Assuming this is okay, or needs similar check?
+        }
+        // Re-initialize factories/clients based on the original config
+        this.embedder = factory_1.EmbedderFactory.create(this.config.embedder.provider, this.config.embedder.config);
+        this.llm = factory_1.LLMFactory.create(this.config.llm.provider, this.config.llm.config);
+        // Re-init DB if needed (though db.reset() likely handles its state)
+        // Re-init Graph if needed
+        // Re-initialize telemetry
+        // this._initializeTelemetry();
+    }
+    async getAll(userId, config) {
+        // await this._captureEvent("get_all", {
+        //   limit: config.limit,
+        //   has_agent_id: !!config.agentId,
+        //   has_run_id: !!config.runId,
+        // });
+        const { agentId, runId, limit = 10, type } = config;
+        const vectorStore = await this.getVectorStore(userId);
+        const filters = {};
+        if (agentId)
+            filters.agentId = agentId;
+        if (runId)
+            filters.runId = runId;
+        if (type)
+            filters.type = type;
+        const [memories] = await vectorStore.list(filters, limit);
+        const excludedKeys = new Set([
+            "userId",
+            "agentId",
+            "runId",
+            "hash",
+            "data",
+            "createdAt",
+            "updatedAt",
+        ]);
+        const results = memories.map((mem) => ({
+            id: mem.id,
+            memory: mem.payload.data,
+            hash: mem.payload.hash,
+            type: mem.payload.type,
+            createdAt: mem.payload.createdAt,
+            updatedAt: mem.payload.updatedAt,
+            metadata: Object.entries(mem.payload)
+                .filter(([key]) => !excludedKeys.has(key))
+                .reduce((acc, [key, value]) => ({ ...acc, [key]: value }), {}),
+            ...(mem.payload.agentId && { agentId: mem.payload.agentId }),
+            ...(mem.payload.runId && { runId: mem.payload.runId }),
+        }));
+        return { results };
+    }
+    async createMemory(data, existingEmbeddings, metadata, userId) {
+        const vectorStore = await this.getVectorStore(userId);
+        const memoryId = (0, uuid_1.v4)();
+        const embedding = existingEmbeddings[data] || (await this.embedder.embed(data));
+        const memoryMetadata = {
+            ...metadata,
+            data,
+            hash: (0, crypto_1.createHash)("md5").update(data).digest("hex"),
+            createdAt: new Date().toISOString(),
+        };
+        await vectorStore.insert([embedding], [memoryId], [memoryMetadata]);
+        await this.db.addHistory(memoryId, null, data, "ADD", memoryMetadata.createdAt);
+        return memoryId;
+    }
+    async updateMemory(memoryId, data, existingEmbeddings, metadata = {}, userId) {
+        const vectorStore = await this.getVectorStore(userId);
+        const existingMemory = await vectorStore.get(memoryId);
+        if (!existingMemory) {
+            throw new Error(`Memory with ID ${memoryId} not found`);
+        }
+        const prevValue = existingMemory.payload.data;
+        const embedding = existingEmbeddings[data] || (await this.embedder.embed(data));
+        const newMetadata = {
+            ...metadata,
+            data,
+            hash: (0, crypto_1.createHash)("md5").update(data).digest("hex"),
+            createdAt: existingMemory.payload.createdAt,
+            updatedAt: new Date().toISOString(),
+            ...(existingMemory.payload.agentId && {
+                agentId: existingMemory.payload.agentId,
+            }),
+            ...(existingMemory.payload.runId && {
+                runId: existingMemory.payload.runId,
+            }),
+        };
+        await vectorStore.update(memoryId, embedding, newMetadata);
+        await this.db.addHistory(memoryId, prevValue, data, "UPDATE", newMetadata.createdAt, newMetadata.updatedAt);
+        return memoryId;
+    }
+    async deleteMemory(memoryId, userId) {
+        const vectorStore = await this.getVectorStore(userId);
+        const existingMemory = await vectorStore.get(memoryId);
+        if (!existingMemory) {
+            throw new Error(`Memory with ID ${memoryId} not found`);
+        }
+        const prevValue = existingMemory.payload.data;
+        await vectorStore.delete(memoryId);
+        await this.db.addHistory(memoryId, prevValue, null, "DELETE", undefined, undefined, 1);
+        return memoryId;
+    }
+}
+exports.MemoriesLite = MemoriesLite;

package/dist/memory/memory.types.d.ts

@@ -0,0 +1,23 @@
+import { MemoryType } from "../types";
+import { SearchFilters } from "../types";
+export interface Entity {
+    userId?: string;
+    agentId?: string;
+    runId?: string;
+}
+export interface AddMemoryOptions extends Entity {
+    metadata?: Record<string, any>;
+    filters?: SearchFilters;
+    customFacts?: string;
+    infer?: boolean;
+}
+export interface SearchMemoryOptions extends Entity {
+    limit?: number;
+    filters?: SearchFilters;
+}
+export interface GetAllMemoryOptions extends Entity {
+    limit?: number;
+    type?: MemoryType;
+}
+export interface DeleteAllMemoryOptions extends Entity {
+}

package/dist/memory/memory.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/prompts/index.d.ts

@@ -0,0 +1,102 @@
+import { z } from "zod";
+import { MemoryItem } from "../types";
+export declare const FactRetrievalSchema_simple: z.ZodObject<{
+    facts: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    facts: string[];
+}, {
+    facts: string[];
+}>;
+export declare const FactRetrievalSchema_extended: z.ZodObject<{
+    facts: z.ZodArray<z.ZodObject<{
+        fact: z.ZodString;
+        existing: z.ZodBoolean;
+        type: z.ZodEnum<["assistant_preference", "factual", "episodic", "procedural", "semantic"]>;
+    }, "strip", z.ZodTypeAny, {
+        type: "procedural" | "episodic" | "factual" | "semantic" | "assistant_preference";
+        fact: string;
+        existing: boolean;
+    }, {
+        type: "procedural" | "episodic" | "factual" | "semantic" | "assistant_preference";
+        fact: string;
+        existing: boolean;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    facts: {
+        type: "procedural" | "episodic" | "factual" | "semantic" | "assistant_preference";
+        fact: string;
+        existing: boolean;
+    }[];
+}, {
+    facts: {
+        type: "procedural" | "episodic" | "factual" | "semantic" | "assistant_preference";
+        fact: string;
+        existing: boolean;
+    }[];
+}>;
+export declare const MemoryUpdateSchema: z.ZodObject<{
+    memory: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        text: z.ZodString;
+        event: z.ZodEnum<["ADD", "UPDATE", "DELETE", "NONE"]>;
+        old_memory: z.ZodNullable<z.ZodString>;
+        reason: z.ZodString;
+        type: z.ZodEnum<["factual", "episodic", "procedural", "semantic", "assistant_preference"]>;
+    }, "strict", z.ZodTypeAny, {
+        type: "procedural" | "episodic" | "factual" | "semantic" | "assistant_preference";
+        id: string;
+        text: string;
+        event: "ADD" | "UPDATE" | "DELETE" | "NONE";
+        old_memory: string | null;
+        reason: string;
+    }, {
+        type: "procedural" | "episodic" | "factual" | "semantic" | "assistant_preference";
+        id: string;
+        text: string;
+        event: "ADD" | "UPDATE" | "DELETE" | "NONE";
+        old_memory: string | null;
+        reason: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    memory: {
+        type: "procedural" | "episodic" | "factual" | "semantic" | "assistant_preference";
+        id: string;
+        text: string;
+        event: "ADD" | "UPDATE" | "DELETE" | "NONE";
+        old_memory: string | null;
+        reason: string;
+    }[];
+}, {
+    memory: {
+        type: "procedural" | "episodic" | "factual" | "semantic" | "assistant_preference";
+        id: string;
+        text: string;
+        event: "ADD" | "UPDATE" | "DELETE" | "NONE";
+        old_memory: string | null;
+        reason: string;
+    }[];
+}>;
+/**
+ * Practical Application:
+ *
+ * If the task is "factual" (e.g., "Where do I live?") → retrieve factual memory.
+ * If the task is temporal or event-based ("What was I doing yesterday?") → retrieve episodic memory.
+ * If the task is conceptual ("What does the user think about Marxism?") → retrieve semantic memory.
+ */
+export declare const MEMORY_STRING_SYSTEM = "# DIRECTIVES FOR MEMORIES\n- Information stored in memory is always enclosed within the <memories> tag.\n- Give 10x more weight to the user's current conversation and prioritize answering it first.\n- You must adapt your answer based on the contents found within the <memories> section.\n- If the memories are irrelevant to the user's query, you MUST ignore them.\n- By default, do not reference this section or the memories in your response.\n- Use the memory type only to guide your reasoning. Do not respond to this section of the prompt, nor to the memories themselves \u2014 they are for your reference only.";
+export declare const MEMORY_STRING_PREFIX = "Use these contextual memories to guide your response. Prioritize the user's question. Ignore irrelevant memories.";
+export declare const MEMORY_STRING_SYSTEM_OLD = "# USER AND MEMORIES PREFERENCES:\n- Utilize the provided memories to guide your responses.\n- Disregard any memories that are not relevant.\n- By default, do not reference this section or the memories in your response.\n";
+export declare function getFactRetrievalMessages_O(parsedMessages: string, customRules?: string, defaultLanguage?: string): [string, string];
+export declare function getFactRetrievalMessages(parsedMessages: string, customRules?: string, defaultLanguage?: string): [string, string];
+export declare function getUpdateMemoryMessages(retrievedOldMemory: Array<{
+    id: string;
+    text: string;
+}>, newRetrievedFacts: any[], defaultLanguage?: string): string;
+/**
+ * Practical Application:
+ * see details on prompts/MEMORY_STRING_PREFIX
+ */
+export declare const getMemoriesAsPrefix: (memories: MemoryItem[]) => string;
+export declare const getMemoriesAsSystem: (memories: MemoryItem[], facts?: string[]) => string;
+export declare function parseMessages(messages: string[]): string;
+export declare function removeCodeBlocks(text: string): string;