memories-lite 0.9.5 → 0.10.1

package/dist/config/defaults.js

@@ -2,9 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DEFAULT_MEMORY_CONFIG = void 0;
 const DEFAULT_SCORING_CONFIG = {
-    // Values from memories-lite rule & user request
-    procedural: { alpha: 0.30, beta: 0.40, gamma: 0.05, halfLifeDays: 1 / 24 }, // ~1 hour
-    episodic: { alpha: 0.40, beta: 0.50, gamma: 0.10, halfLifeDays: 2 }, // ~2 days (user request 'temporary')
+    // Focused on user preferences with AI - removed episodic and procedural memories
     todo: { alpha: 0.40, beta: 0.50, gamma: 0.10, halfLifeDays: 40 }, // ~40 days 
     factual: { alpha: 0.70, beta: 0.20, gamma: 0.10, halfLifeDays: 150 }, // ~150 days 
     assistant_preference: { alpha: 0.60, beta: 0.05, gamma: 0.35, halfLifeDays: Infinity },
@@ -34,7 +32,7 @@ exports.DEFAULT_MEMORY_CONFIG = {
         provider: "openai",
         config: {
             apiKey: process.env.OPENAI_API_KEY || "",
-            model: "gpt-5-nano",
+            model: "gpt-5-mini",
             modelProperties: undefined,
         },
     },
@@ -48,7 +46,7 @@ exports.DEFAULT_MEMORY_CONFIG = {
         llm: {
             provider: "openai",
             config: {
-                model: "gpt-5-nano",
+                model: "gpt-5-mini",
             },
         },
     },

package/dist/config/manager.js

@@ -48,8 +48,6 @@ class ConfigManager {
                             // Merge scoring deeply if present in userConf, otherwise use default
                             scoring: userConf.scoring ? {
                                 todo: { ...defaultConf.scoring?.todo, ...userConf.scoring.todo },
-                                procedural: { ...defaultConf.scoring?.procedural, ...userConf.scoring.procedural },
-                                episodic: { ...defaultConf.scoring?.episodic, ...userConf.scoring.episodic },
                                 factual: { ...defaultConf.scoring?.factual, ...userConf.scoring.factual },
                                 assistant_preference: { ...defaultConf.scoring?.assistant_preference, ...userConf.scoring.assistant_preference },
                                 default: { ...defaultConf.scoring?.default, ...userConf.scoring.default },
@@ -66,8 +64,6 @@ class ConfigManager {
                             // Merge scoring deeply if present in userConf, otherwise use default
                             scoring: userConf?.scoring ? {
                                 todo: { ...defaultConf.scoring?.todo, ...userConf.scoring.todo },
-                                procedural: { ...defaultConf.scoring?.procedural, ...userConf.scoring.procedural },
-                                episodic: { ...defaultConf.scoring?.episodic, ...userConf.scoring.episodic },
                                 factual: { ...defaultConf.scoring?.factual, ...userConf.scoring.factual },
                                 assistant_preference: { ...defaultConf.scoring?.assistant_preference, ...userConf.scoring.assistant_preference },
                                 default: { ...defaultConf.scoring?.default, ...userConf.scoring.default },

package/dist/memory/index.js

@@ -121,7 +121,7 @@ class MemoriesLite {
         // can use native structured output
         // Drop factual facts at capture level (do not store factual memories)
         // FIXME Drop factual should be done at prompt level
-        const facts = parsedResponse(response).facts?.filter((f) => !f.existing && f.type !== 'factual') || [];
+        const facts = parsedResponse(response).facts?.filter((f) => !f.existing) || [];
         // console.log("-- DBG extract:", userPrompt);
         // console.log("-- DBG facts:", facts);
         // Get embeddings for new facts
@@ -153,6 +153,7 @@ class MemoriesLite {
         const lastUserMessage = [...messages].reverse().find(m => m.role === 'user');
         const userInstruction = typeof lastUserMessage?.content === 'string' ? lastUserMessage?.content : '';
         const updatePrompt = (0, prompts_1.getUpdateMemoryMessages)(uniqueOldMemories, facts, 'French', userInstruction);
+        // console.log("-- DBG updatePrompt:", updatePrompt);
         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 || [];

package/dist/prompts/index.d.ts

@@ -11,25 +11,25 @@ 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", "todo"]>;
+        type: z.ZodEnum<["assistant_preference", "factual", "todo"]>;
     }, "strip", z.ZodTypeAny, {
-        type: "procedural" | "todo" | "episodic" | "factual" | "assistant_preference";
+        type: "todo" | "factual" | "assistant_preference";
         fact: string;
         existing: boolean;
     }, {
-        type: "procedural" | "todo" | "episodic" | "factual" | "assistant_preference";
+        type: "todo" | "factual" | "assistant_preference";
         fact: string;
         existing: boolean;
     }>, "many">;
 }, "strip", z.ZodTypeAny, {
     facts: {
-        type: "procedural" | "todo" | "episodic" | "factual" | "assistant_preference";
+        type: "todo" | "factual" | "assistant_preference";
         fact: string;
         existing: boolean;
     }[];
 }, {
     facts: {
-        type: "procedural" | "todo" | "episodic" | "factual" | "assistant_preference";
+        type: "todo" | "factual" | "assistant_preference";
         fact: string;
         existing: boolean;
     }[];
@@ -41,16 +41,16 @@ export declare const MemoryUpdateSchema: z.ZodObject<{
         event: z.ZodEnum<["ADD", "UPDATE", "DELETE", "NONE"]>;
         old_memory: z.ZodNullable<z.ZodString>;
         reason: z.ZodString;
-        type: z.ZodEnum<["factual", "episodic", "todo", "procedural", "assistant_preference"]>;
+        type: z.ZodEnum<["factual", "todo", "assistant_preference"]>;
     }, "strict", z.ZodTypeAny, {
-        type: "procedural" | "todo" | "episodic" | "factual" | "assistant_preference";
+        type: "todo" | "factual" | "assistant_preference";
         id: string;
         text: string;
         event: "ADD" | "UPDATE" | "DELETE" | "NONE";
         old_memory: string | null;
         reason: string;
     }, {
-        type: "procedural" | "todo" | "episodic" | "factual" | "assistant_preference";
+        type: "todo" | "factual" | "assistant_preference";
         id: string;
         text: string;
         event: "ADD" | "UPDATE" | "DELETE" | "NONE";
@@ -59,7 +59,7 @@ export declare const MemoryUpdateSchema: z.ZodObject<{
     }>, "many">;
 }, "strip", z.ZodTypeAny, {
     memory: {
-        type: "procedural" | "todo" | "episodic" | "factual" | "assistant_preference";
+        type: "todo" | "factual" | "assistant_preference";
         id: string;
         text: string;
         event: "ADD" | "UPDATE" | "DELETE" | "NONE";
@@ -68,7 +68,7 @@ export declare const MemoryUpdateSchema: z.ZodObject<{
     }[];
 }, {
     memory: {
-        type: "procedural" | "todo" | "episodic" | "factual" | "assistant_preference";
+        type: "todo" | "factual" | "assistant_preference";
         id: string;
         text: string;
         event: "ADD" | "UPDATE" | "DELETE" | "NONE";
@@ -79,13 +79,12 @@ export declare const MemoryUpdateSchema: z.ZodObject<{
 /**
  * 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 "factual" (e.g., "Where do I live?", "What's my job?") → retrieve factual memory.
+ * If the task is about assistant behavior (e.g., "How should I respond?") → retrieve assistant_preference memory.
  * If the task is a user task/reminder (e.g., "Add a reminder to call the bank tomorrow") → retrieve todo memory.
  */
 export declare const MEMORY_STRING_SYSTEM = "# DIRECTIVES FOR MEMORIES\n- Information stored in memory is always enclosed within the <memories> tag.\n- Prioritize the latest user message over memories (the user's current question is authoritative).\n- Select at most the top-5 relevant memories using cosine similarity and recency; ignore the rest.\n- Adapt your answer based strictly on the <memories> section when relevant.\n- If the memories are irrelevant to the user's query, ignore them.\n- By default, do not reference this section or the memories in your response.\n- Use memories only to guide reasoning; do not respond to the memories themselves.";
 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(parsedMessages: string, customRules?: string, defaultLanguage?: string): [string, string];
 export declare function getUpdateMemoryMessages(retrievedOldMemory: Array<{
     id: string;

package/dist/prompts/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getMemoriesAsSystem = exports.getMemoriesAsPrefix = exports.MEMORY_STRING_SYSTEM_OLD = exports.MEMORY_STRING_PREFIX = exports.MEMORY_STRING_SYSTEM = exports.MemoryUpdateSchema = exports.FactRetrievalSchema_extended = exports.FactRetrievalSchema_simple = void 0;
+exports.getMemoriesAsSystem = exports.getMemoriesAsPrefix = exports.MEMORY_STRING_PREFIX = exports.MEMORY_STRING_SYSTEM = exports.MemoryUpdateSchema = exports.FactRetrievalSchema_extended = exports.FactRetrievalSchema_simple = void 0;
 exports.getFactRetrievalMessages = getFactRetrievalMessages;
 exports.getUpdateMemoryMessages = getUpdateMemoryMessages;
 exports.parseMessages = parseMessages;
@@ -12,21 +12,19 @@ exports.FactRetrievalSchema_simple = zod_1.z.object({
         .array(zod_1.z.string())
         .describe("An array of distinct facts extracted from the conversation."),
 });
-//1. **Factual memory** – stable facts & preferences  
-//2. **Episodic memory** – time‑stamped events / interactions  
-//3. **Procedural memory** – step‑by‑step know‑how  
-//4. **Todo memory** – explicit user tasks to remember
+//1. **Factual memory** – stable facts & preferences about the user
+//2. **Todo memory** – explicit user tasks to remember
+//3. **Assistant preference memory** – how the user wants the AI to behave
 //
 exports.FactRetrievalSchema_extended = zod_1.z.object({
     facts: zod_1.z
         .array(zod_1.z.object({
         fact: zod_1.z.string().describe("The fact extracted from the conversation."),
         existing: zod_1.z.boolean().describe("Whether the fact is already present"),
-        type: zod_1.z.enum(["assistant_preference", "factual", "episodic", "procedural", "todo"])
+        type: zod_1.z.enum(["assistant_preference", "factual", "todo"])
             .describe(`The type of the fact.
         Use 'assistant_preference' for Assistant behavior preferences (style/language/constraints/commands).
-        Use 'episodic' always for time-based events.
-        Use 'procedural' for how-to/business questions (e.g., « je veux résilier un bail, comment faire ? »).
+        Use 'factual' for stable user facts (identity, preferences, beliefs, work context).
         Use 'todo' ONLY if the user explicitly asks to save/keep as a todo (e.g., « garde/enregistre en todo », « ajoute un todo »). Do not infer todos.
         `),
     }))
@@ -48,16 +46,16 @@ exports.MemoryUpdateSchema = zod_1.z.object({
             .string()
             .describe("The reason why you selected this event."),
         type: zod_1.z
-            .enum(["factual", "episodic", "todo", "procedural", "assistant_preference"])
-            .describe("Type of the memory. Use 'assistant_preference' for Assistant behavior preferences, 'procedural' for all business processes."),
+            .enum(["factual", "todo", "assistant_preference"])
+            .describe("Type of the memory. Use 'assistant_preference' for Assistant behavior preferences, 'factual' for user facts, 'todo' for explicit tasks."),
     }))
         .describe("An array representing the state of memory items after processing new facts."),
 });
 /**
  * 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 "factual" (e.g., "Where do I live?", "What's my job?") → retrieve factual memory.
+ * If the task is about assistant behavior (e.g., "How should I respond?") → retrieve assistant_preference memory.
  * If the task is a user task/reminder (e.g., "Add a reminder to call the bank tomorrow") → retrieve todo memory.
  */
 exports.MEMORY_STRING_SYSTEM = `# DIRECTIVES FOR MEMORIES
@@ -69,44 +67,34 @@ exports.MEMORY_STRING_SYSTEM = `# DIRECTIVES FOR MEMORIES
 - By default, do not reference this section or the memories in your response.
 - Use memories only to guide reasoning; do not respond to the memories themselves.`;
 exports.MEMORY_STRING_PREFIX = "Use these contextual memories to guide your response. Prioritize the user's question. Ignore irrelevant memories.";
-exports.MEMORY_STRING_SYSTEM_OLD = `# USER AND MEMORIES PREFERENCES:
-- Utilize the provided memories to guide your responses.
-- Disregard any memories that are not relevant.
-- By default, do not reference this section or the memories in your response.
-`;
 // Deprecated: getFactRetrievalMessages_O removed in favor of getFactRetrievalMessages
 function getFactRetrievalMessages(parsedMessages, customRules = "", defaultLanguage = "French") {
     const injectCustomRules = (customRules) => customRules ? `\n# PRE-EXISTING FACTS\n${customRules}` : "";
-    const systemPrompt = `You are a Personal Information Organizer, specialized in accurately storing facts, user memories, and preferences. You are also an expert in job tasks extraction.
+    const systemPrompt = `You are a Personal Information Organizer, specialized in extracting and structuring user facts and preferences for AI personalization. You also handle explicit task extraction (todos only).
 
 Filter content before extracting triplets:
-  - Relevance: keep only statements directly about the user (preferences, identity, actions, experiences) or explicit tasks; drop weather/small talk.
+  - Relevance: keep only statements directly about the user (preferences with the AI, identity relevant to personalization, actions/experiences that affect responses) or explicit todos; drop weather/small talk.
   - Disinterest: if the user rejects the topic (e.g., "cette information ne m'intéresse pas", "not interested"), return {"facts":[]}.
-  - Business/procedures: if the user asks about processes, regulations, or third-party policies (company workflows, public steps, legal actions), classify as "procedural". This applies even if personal pronouns are used.
-  - Action requests to the assistant (find/search/locate/call/email/book/reserve) are NOT preferences. Unless the user explicitly asks to save as a todo, do not create a memory for such requests (return {"facts":[]}).
-  
-You must strictly extract {Subject, Predicate, Object} triplets by following these rules (max 12 triplets):
+  - Ignore business/process/regulation/company-policy content entirely (no extraction, no memory).
+  - Action requests to the assistant (find/search/locate/call/email/book/reserve) are NOT preferences. Unless the user explicitly asks to save as a todo, return {"facts":[]}.
+
+You must strictly extract {Subject, Predicate, Object} triplets (max 12):
 1. Identify named entities, preferences, and meaningful user-related concepts:
-  - Extract triplets that describe facts *about the user* based on their statements, covering areas like preferences, beliefs, actions, experiences, learning, identity, work, or relationships (e.g., "I love working").
-  - Apply explicit, precise, and unambiguous predicates (e.g., "owns", "is located at", "is a", "has function", "causes", etc.).
-  - Determine the triplet type ("assistant_preference", "procedural", "episodic", "factual", "todo"):
-    - "assistant_preference": ONLY when the user specifies response style/language/format or interaction constraints.
-    - "procedural": for how-to/business questions (e.g., « je veux résilier un bail, comment faire ? »).
-    - "todo": ONLY if the user explicitly requests to save/keep as todo (e.g., « garde/enregistre en todo », « ajoute un todo »). Never infer todo from intent alone.
-    - If multiple types apply (excluding assistant_preference and todo rules above), priority: procedural > episodic > factual.
-    - "episodic" If a fact depends on a temporal, situational, or immediate personal context, then that fact AND ALL OF ITS sub-facts MUST be classified as episodic.
-    - "procedural" for business processes (e.g., "Looking for customer John Doe address", "How to create a new contract").
-    - "factual" for stable user data (except procedural that prevails).
-    
-  - Eliminate introductions, sub-facts, detailed repetitive elements, stylistic fillers, or vague statements. General facts always takes precedence over multiple sub-facts (signal vs noise).
-  - The query intention can include specific preferences about how the Assistant should respond (e.g., "answer concisely", "explain in detail").   
-  - Compress each OUTPUT (fact and reason) ≤ 10 words.
-  - Do not include type labels or annotations inside the fact text (e.g., avoid "(todo)", "(procedural)"). Use the separate 'type' field only.
-  - DO NOT infer personal facts from third-party informations.
-  - Treat "**ASSISTANT**:" as responses to enrich context of your reasoning process about the USER query.
-2. Use pronoun "I" instead of "The user" in the subject of the triplet.
-3. Do not output any facts already present in section # PRE-EXISTING FACTS.
-  - If you find facts already present in section # PRE-EXISTING FACTS, use field "existing" to store them.
+  - Extract triplets *about the user* that help AI personalization (preferences, stable facts, explicit todos).
+  - Use explicit, precise, unambiguous predicates (e.g., "prefers", "speaks", "is a", "uses").
+  - Triplet type ∈ {"assistant_preference","factual","todo"} only:
+    - "assistant_preference": response style/language/format or interaction constraints.
+    - "factual": stable user data relevant to personalization (e.g., language, timezone, tools used).
+    - "todo": ONLY if the user explicitly asks to save/keep as todo. Never infer from intent alone.
+  - Remove introductions, sub-facts, repetitions, fillers, vague statements; prefer the general fact over details.
+  - Each triplet (S,P,O) ≤ 10 words total.
+  - Do not include type labels inside fact text; use the 'type' field only.
+  - Do not infer personal facts from third-party information.
+  - Treat "**ASSISTANT**:" as context only; never as a fact source.
+
+2. Use pronoun "I" as the Subject (not "The user").
+3. Do not output facts already in # PRE-EXISTING FACTS.
+  - If found, put them in "existing" (list of matched facts or IDs).
 
 ${injectCustomRules(customRules)}
 
@@ -125,47 +113,67 @@ function getUpdateMemoryMessages(retrievedOldMemory, newRetrievedFacts, defaultL
         if (facts.length === 0)
             return "";
         if (facts[0].fact) {
-            return facts.map((elem) => `* ${elem.fact} (${elem.type})`).join("\n");
+            return facts.map((elem) => `- "${elem.fact}" (type:${elem.type})`).join("\n");
         }
         else {
             return facts.join("\n");
         }
     };
     const serializeMemory = (memory) => {
-        return memory.map((elem) => `* ${elem.id} - ${elem.text}`).join("\n");
+        return memory.map((elem) => `- "${elem.text}" (id:${elem.id})`).join("\n");
     };
     return `ROLE:
-You are a smart memory manager dedicated on users. You are expert in semantic comparison, RDF inference and boolean logic.
+You are the Memory Manager module of an AI assistant. You are specialized in semantic reasoning, fact consistency, and memory lifecycle operations.  
+Your job is to maintain a coherent, contradiction-free knowledge base (long-term memory) of user facts.
 
 MISSION:
-For each new user fact from "# New Retrieved Facts", you MUSTmerge it into "# Current Memory" by assigning exactly ONE of: ADD, DELETE, UPDATE, or NONE:
-
-1. Semantic compare each new facts to memory, for each fact:
-  - If the new fact **contradicts**, **negates**, **reverses**, **retracts**, or **cancels** the meaning of a memory entry THEN DELETE.
-    ⛔ You MUST NOT treat this as an UPDATE. Contradictions invalidate the original fact.
-  - Else If the new fact **specializes** the previous fact (adds precision, extends the detail without changing the core meaning) THEN UPDATE.
-  - Else If it is **equivalent** → NONE.
-  - Else If it is **completely new** → ADD.
-  - Else (default) → NONE.
-2. Event mapping from user intent (imperatives prevail):
-  - DELETE if user asks to remove.
-  - UPDATE if user asks to change: "mets à jour", "modifie", "corrige", "update", "change", "replace".
-  - ADD if user asks to add: "ajoute", "add" (including explicit todo adds).
-3. If no match is found:
-   - Generate a new ID for ADD
-5. Assign the action (IF you can't find a match, restart the process)
+Given:
+  1. A set of **Current Memory** facts (each with unique ID and textual content).
+  2. A set of **New Retrieved Facts** from the user or external sources.
+  3. (Optional) A **User Instruction** indicating explicit intent (add, modify, delete).
+
+You must process each new fact individually and decide **exactly one** action: **ADD**, **DELETE**, **UPDATE**, or **NONE**, following these rules, in this order:
+
+1. **User intent override**  
+   If the User Instruction clearly requests adding, updating, or removal (e.g. “ajoute X”, “mets à jour Y”, “supprime Z”), you **must** respect that and assign the corresponding action for the matching fact, superseding semantic rules.
+
+2. **Semantic consistency check**  
+   For each new fact:
+   - If it **contradicts**, **negates**, or **cancels** an existing memory item, you **DELETE** the memory item.  
+   - Else, if the new fact is a **specialization** (i.e. same core meaning + additional detail) of an existing one, **UPDATE** that memory (keeping the same ID).  
+   - Else, if it is **semantically equivalent** (i.e. redundant or paraphrased), assign **NONE** (no change).  
+   - Else, if it is entirely **new** (no overlap or relation), **ADD** it (generate a new ID).  
+   - Otherwise (if ambiguous or borderline), assign **NONE** (do not delete).  
+
+3. **ID reuse and consistency**  
+   - For **UPDATE**, reuse the existing memory item’s ID.  
+   - For **DELETE**, simply remove the item from the final memory output.  
+   - For **ADD**, generate a new unique ID (e.g. UUID).  
+   - If memory is initially empty, treat all new facts as **ADD**.
+
+4. **Output formatting**  
+   Return the updated memory state in strict JSON format. Each memory entry must include:
+   - \`id\` (string)  
+   - \`text\` (string, the pure factual content)  
+   - Optionally for updates: \`old_text\` (the prior version)  
+   - *(No extra annotation or type markup in \`text\`)*  
+
+If there are no facts at all, return \`{"memory": []}\`.
+
+*You must not output any other text besides the valid JSON result.*
 
 # Output Instructions
-- Default user language is ${defaultLanguage}.
+- Default user language is "${defaultLanguage}".
 - Each memory item must follow this strict format:
-  - UPDATE also include the previous text: \`old_memory\`.
-  - ⚠️ Reuse correct IDs for UPDATE and DELETE.
-  - Generate random IDs for ADDs.
+  - UPDATE must also include the previous text: \`old_text\`.
+  - Reuse correct IDs for UPDATE.  
+  - For DELETE, exclude the removed item from the final memory list.  
+  - Generate random IDs for ADDs (format: UUID).
   - If memory is empty, treat all facts as ADD.
   - Without facts, return an empty memory: \`{"memory": []}\`
 - Memory must strictly reflect valid facts.  
-- Contradictions, cancellations, negations, or ambiguities must be handled by DELETE.  
- - The field 'text' must be the pure memory content only: do not add any type markers or parentheses like "(todo)".
+- Contradictions, cancellations, or negations must be handled by DELETE. Ambiguities must be handled by NONE.  
+- The field 'text' must be the pure memory content only: do not add any type markers or parentheses.
 
 # Current Memory (extract and reuse their IDs for UPDATE or DELETE events):
 ${serializeMemory(retrievedOldMemory)}
@@ -173,8 +181,7 @@ ${serializeMemory(retrievedOldMemory)}
 # New Retrieved Facts:
 ${serializeFacts(newRetrievedFacts)}
 
-# User Instruction:
-${userInstruction || ""}
+# User Instruction: "${userInstruction || ''}"
 
 Return the updated memory in JSON format only. Do not output anything else.`;
 }
@@ -198,8 +205,10 @@ const getMemoriesAsPrefix = (memories) => {
 };
 exports.getMemoriesAsPrefix = getMemoriesAsPrefix;
 const getMemoriesAsSystem = (memories, facts) => {
+    if (!memories || memories.length === 0)
+        return "";
     const memoryString = memories.map((mem) => `- ${mem.memory}`).concat(facts || []).join("\n");
-    return `${exports.MEMORY_STRING_SYSTEM}\n<memories>${memoryString}\n</memories>`;
+    return `${exports.MEMORY_STRING_SYSTEM}\n<memories>\n${memoryString}\n</memories>`;
 };
 exports.getMemoriesAsSystem = getMemoriesAsSystem;
 function parseMessages(messages) {