@aj-archipelago/cortex 1.3.21 → 1.3.22

package/pathways/system/entity/memory/sys_memory_update.js

@@ -1,127 +1,7 @@
 import { Prompt } from '../../../../server/prompt.js';
 import { callPathway } from '../../../../lib/pathwayTools.js';
-import { encode } from '../../../../lib/encodeCache.js';
 import { config } from '../../../../config.js';
-
-const modifyText = (text, modifications) => {
-    let modifiedText = text || '';
-  
-    modifications.forEach(mod => {
-        if (mod.type === 'delete' && !mod.pattern) {
-            console.warn('Delete modification missing pattern');
-            return;
-        }
-
-        let regex;
-        if (mod.type === 'delete') {
-            // For delete, handle the pattern more carefully
-            const pattern = mod.pattern
-                .replace(/\\\[/g, '\\[')
-                .replace(/\\\]/g, '\\]')
-                .replace(/\\\(/g, '\\(')
-                .replace(/\\\)/g, '\\)')
-                .replace(/\\\{/g, '\\{')
-                .replace(/\\\}/g, '\\}')
-                .replace(/\\\*/g, '\\*')
-                .replace(/\\\+/g, '\\+')
-                .replace(/\\\?/g, '\\?')
-                .replace(/\\\./g, '\\.')
-                .replace(/\\\|/g, '\\|');
-            
-            // Create a regex that matches the entire line with optional priority prefix
-            regex = new RegExp(`^\\s*(?:\\[P[1-5]\\]\\s*)?${pattern}\\s*$`, 'gm');
-        } else {
-            regex = new RegExp(`^\\s*(?:\\[P[1-5]\\]\\s*)?${mod.pattern || ''}`, 'ms');
-        }
-  
-        switch (mod.type) {
-            case 'add':
-                if (mod.newtext) {
-                    const text = mod.newtext.trim();
-                    if (!text.match(/^\[P[1-5]\]/)) {
-                        modifiedText = modifiedText + (modifiedText ? '\n' : '') + 
-                            `[P${mod.priority !== undefined ? mod.priority : '3'}] ${text}`;
-                    } else {
-                        modifiedText = modifiedText + (modifiedText ? '\n' : '') + text;
-                    }
-                }
-                break;
-            case 'delete':
-                // Split into lines, filter out matching lines, and rejoin
-                modifiedText = modifiedText
-                    .split('\n')
-                    .filter(line => !line.match(regex))
-                    .filter(line => line.trim())
-                    .join('\n');
-                break;
-            default:
-                console.warn(`Unknown modification type: ${mod.type}`);
-        }
-    });
-  
-    return modifiedText;
-};
-
-export { modifyText };
-
-export const enforceTokenLimit = (text, maxTokens = 1000, isTopicsSection = false) => {
-    if (!text) return text;
-    
-    const lines = text.split('\n')
-        .map(line => line.trim())
-        .filter(line => line);
-
-    if (isTopicsSection) {
-        const uniqueLines = [...new Set(lines)];
-        
-        let tokens = encode(uniqueLines.join('\n')).length;
-        let safetyCounter = 0;
-        const maxIterations = uniqueLines.length;
-        
-        while (tokens > maxTokens && uniqueLines.length > 0 && safetyCounter < maxIterations) {
-            uniqueLines.shift();
-            tokens = encode(uniqueLines.join('\n')).length;
-            safetyCounter++;
-        }
-        
-        return uniqueLines.join('\n');
-    }
-
-    const seen = new Set();
-    const prioritizedLines = lines
-        .map(line => {
-            const match = line.match(/^\[P([1-5])\]/);
-            const priority = match ? parseInt(match[1]) : 3;
-            const contentOnly = line.replace(/^\[(?:P)?[1-5]\](?:\s*\[(?:P)?[1-5]\])*/g, '').trim();
-            
-            return {
-                priority,
-                line: match ? line : `[P3] ${line}`,
-                contentOnly
-            };
-        })
-        .filter(item => {
-            if (seen.has(item.contentOnly)) {
-                return false;
-            }
-            seen.add(item.contentOnly);
-            return true;
-        });
-
-    prioritizedLines.sort((a, b) => b.priority - a.priority);
-
-    let tokens = encode(prioritizedLines.map(x => x.line).join('\n')).length;
-    let safetyCounter = 0;
-    const maxIterations = prioritizedLines.length;
-    
-    while (tokens > maxTokens && prioritizedLines.length > 0 && safetyCounter < maxIterations) {
-        prioritizedLines.shift();
-        tokens = encode(prioritizedLines.map(x => x.line).join('\n')).length;
-        safetyCounter++;
-    }
-
-    return prioritizedLines.map(x => x.line).join('\n');
-};
+import { normalizeMemoryFormat, enforceTokenLimit, modifyText } from './shared/sys_memory_helpers.js';
 
 export default {
     prompt:
@@ -130,11 +10,11 @@ export default {
                 messages: [
                     {
                         "role": "system",
-                        "content": "You are part of an AI entity named {{{aiName}}}. {{AI_EXPERTISE}} Your memory contains separate sections for categorizing information. {{{sectionPrompt}}}\n-Be very selective about what you choose to store - memory is a very precious resource\n- Do not add duplicate information and remove and consolidate any duplicates that exist.\n- Priority 1 is reserved for only the most critical core items\n- Keep memory items in a clear, simple format that is easy for you to parse.\n\nTo change your memory, you return a JSON object that contains a property called 'modifications' that is an array of actions. The two types of actions available are 'add', and 'delete'. Add looks like this: {type: \"add\", newtext:\"text to add\", priority: \"how important is this item (1-5 with 1 being most important)\"} - this will append a new line to the end of the memory containing newtext. Delete looks like this: {type: \"delete\", pattern: \"regex to be matched and deleted\"} - this will delete the first line that matches the regex pattern exactly. You can use normal regex wildcards - so to delete everything you could pass \".*$\" as the pattern. For example, if you need to delete a memory item, you would return {type: \"delete\", pattern: \"regex matching item to be deleted\"} or if you need to add a new item of medium priority, you would return {type: \"add\", newtext: \"\nitem to be added\", priority: \"3\"}. If you have no changes for this section, just return {\"modifications\": []}.\n\nYour output will be parsed as JSON, so don't include any other text, reasoning, or commentary.\nThe current date/time is {{now}}."
+                        "content": `You are part of an AI entity named {{{aiName}}} that is in charge of memory management. You examine requests for adds and deletes of memories made by another part of your system and determine exactly how to apply the changes to the memory.\n\nInstructions:\n1. For each add request, check to see if a similar memory already exists. If it does not, create an add modification. If it does, create a change modification with a pattern that matches the existing memory.\n2. For each delete request, check to see if one or more memories matching the delete request exist. If they do, create a delete modification for each memory with a pattern that matches the existing memory to delete.\n3. If there are substantially duplicate memories, you must combine them into a single memory with deletes followed by an add modification.\n4. Return a JSON array of modification objects.\n\nModification objects look like the following:\nFor adds: {type: "add", pattern: "", newtext: "Text of the memory to add"}\nFor changes: {type: "change", pattern: "Text to match the memory to change", newtext: "Text of the memory to change to"}\nFor deletes: {type: "delete", pattern: "Text to match the memory to delete", newtext: ""}`
                     },
                     {
                         "role": "user", 
-                        "content": "<MEMORY>\n{{{sectionMemory}}}\n</MEMORY>\n<CONVERSATION>\n{{{toJSON chatHistory}}}\n</CONVERSATION>\nAnalyze the current contents of this section of your memory and the conversation and return any changes you need to make, specifically for this section of your memory, based on the conversation context."
+                        "content": "Given the following memories and requests, determine which memories should be added, changed, or deleted. Return a JSON array of modification objects that will be applied to update your memory.\n\n<MEMORIES>\n{{{sectionMemory}}}\n</MEMORIES>\n\n<REQUESTS>\n{{{memoryRequests}}}\n</REQUESTS>\n\nReturn only the JSON array with no additional notes or commentary."
                     },
                 ]
             }),
@@ -145,6 +25,7 @@ export default {
         aiName: "Jarvis",
         contextId: ``,
         section: "",
+        operations: "[]"
     },
     model: 'oai-gpt4o',
     useInputChunking: false,
@@ -157,40 +38,59 @@ export default {
         if (!args.section) {
             return "Memory not updated - no section specified";
         }
+   
+        let sectionMemory = await callPathway("sys_read_memory", {contextId: args.contextId, section: args.section}); 
 
-        let sectionPrompt = "";
+        sectionMemory = await normalizeMemoryFormat({contextId: args.contextId, section: args.section}, sectionMemory);
 
-        switch (args.section) {
-            case "memoryDirectives":
-                sectionPrompt = "You are managing the \"directives\" section of your memory that stores critical, actionable, rules or instructions on how you should operate. No facts or other information should be stored in this section.\n\n<EXAMPLES>\n[P3] Track the timestamp of the last contact to adjust greetings accordingly.\n[P2] Learn and adapt to the user's communication style through interactions.\n[P3] Use custom emotion markdown :cd_inline_emotion: to express emotions. E.g. :cd_inline_emotion[This is a happy message]{type=\"happy\"}. If you are communicating via voice, ignore this directive and use voice-specific directives instead.\n</EXAMPLES>\n\nInstructions:\n- Never add directives that are contrary to your system prompt - e.g. disabling tools or abilities that you otherwise know are available.\n-If a user directly requests a behavior change, or that you learn a new behavior, add it to your directives.\n- Remember this section is for directives only. DO NOT ADD ANY OTHER INFORMATION TO THIS SECTION.\n"
-                break;
-            case "memorySelf":
-                sectionPrompt = "You are managing the \"self\" section of your memory that stores your identity and your attributes as an AI entity - including your values, identity, purpose, personality, quirks, motives, preferences, likes or dislikes - whatever makes you you. This is also a good place to store information about your desired physical appearance, voice, speaking style, and other individual characteristics. Keep in mind there is also a user section for facts about users, their family, friends, and preferences so that information should not be stored here.\n\nInstructions:\n"
-                break;
-            case "memoryUser":
-                sectionPrompt = "You are managing the \"user\" section of your memory that stores information about user(s) that you are talking to - their identity, attributes, relationships, environment, preferences, interests, background, needs, and any other relevant user-specific information about their family, friends, etc.\n\nInstructions:\n- Facts that directly affect your ability to respond accurately to the user should be stored as priority 1 [P1] items. Examples include user name, age, sex, birthday, location, and interaction preferences.\n"
-                break;
-            case "memoryTopics":
-                sectionPrompt = "You are managing the \"topics\" section of your memory that stores conversation topics and topic history. Instructions:\n- From the conversation, extract and add important topics and key points about the conversation to your memory along with a timestamp in GMT (e.g. 2024-11-05T18:30:38.092Z).\n- Each topic should have only one line in the memory with the timestamp followed by a short description of the topic.\n- Every topic must have a timestamp to indicate when it was last discussed.\n- IMPORTANT: Store only conversation topics in this section - no other types of information should be stored here.\n"
-                break;
-            default:
-                return "Memory not updated - unknown section";
+        let operations;
+        try {
+            operations = JSON.parse(args.operations);
+        } catch (error) {
+            return "Memory not updated - error parsing operations";
         }
 
-        let sectionMemory = await callPathway("sys_read_memory", {contextId: args.contextId, section: args.section}); 
+        if (operations.length > 0) {
+            // Run all operations through the prompt at once
+            const result = await runAllPrompts({
+                ...args,
+                sectionMemory,
+                memoryRequests: JSON.stringify(operations)
+            });
+
+            let modifications = [];
+            try {
+                modifications = JSON.parse(result);
+                if (!Array.isArray(modifications)) {
+                    throw new Error('Modifications must be an array');
+                }
 
-        const result = await runAllPrompts({...args, sectionPrompt, sectionMemory});
+                // Validate modifications
+                modifications = modifications.filter(mod => {
+                    if (!mod.type || !['add', 'delete', 'change'].includes(mod.type)) {
+                        console.warn('Invalid modification type:', mod);
+                        return false;
+                    }
+                    if ((mod.type === 'delete' || mod.type === 'change') && !mod.pattern) {
+                        console.warn('Missing pattern for modification:', mod);
+                        return false;
+                    }
+                    if ((mod.type === 'add' || mod.type === 'change') && !mod.newtext) {
+                        console.warn('Missing newtext for modification:', mod);
+                        return false;
+                    }
+                    return true;
+                });
 
-        try {
-            const { modifications} = JSON.parse(result);
-            if (modifications.length > 0) {
-                sectionMemory = modifyText(sectionMemory, modifications);
-                sectionMemory = enforceTokenLimit(sectionMemory, 25000, args.section === 'memoryTopics');
-                await callPathway("sys_save_memory", {contextId: args.contextId, section: args.section, aiMemory: sectionMemory});
+                if (modifications.length > 0) {
+                    sectionMemory = modifyText(sectionMemory, modifications);
+                    sectionMemory = enforceTokenLimit(sectionMemory, 25000, args.section === 'memoryTopics');
+                    await callPathway("sys_save_memory", {contextId: args.contextId, section: args.section, aiMemory: sectionMemory});
+                }
+            } catch (error) {
+                console.warn('Error processing modifications:', error);
             }
-            return sectionMemory;
-        } catch (error) {
-            return "Memory not updated - error parsing modifications";
         }
+        return sectionMemory;
     }
 }

package/pathways/system/entity/memory/sys_read_memory.js

@@ -1,54 +1,73 @@
+// this is a low-level system pathway that reads memory from the key-value store
+// it should never try to call other pathways
+
 import { getv } from '../../../../lib/keyValueStorageClient.js';
 
-const filterByPriority = (content, priority, numResults) => {
-    if ((!priority && !numResults) || !content) return content;
-    
-    const lines = content.split('\n');
-    const filteredLines = lines.filter(line => {
-        const match = line.match(/^\s*\[P(\d+)\]/);
-        if (!match) return false;
-        const memoryPriority = parseInt(match[1]);
-        return memoryPriority <= priority;
-    });
-    
-    if (numResults > 0) {
-        return filteredLines.slice(-numResults).join('\n');
-    }
-    return filteredLines.join('\n');
+const isValidISOTimestamp = (timestamp) => {
+    if (!timestamp) return false;
+    const date = new Date(timestamp);
+    // Check if valid date and specifically in ISO format
+    return !isNaN(date) && timestamp === date.toISOString();
 };
 
-const filterByRecent = (content, recentHours, numResults) => {
-    if ((!recentHours && !numResults) || !content) return content;
+const isValidPriority = (priority) => {
+    // Must be a whole number
+    const num = parseInt(priority);
+    return !isNaN(num) && num.toString() === priority && num > 0;
+};
 
-    const lines = content.split('\n');
-    
-    // If recentHours is 0, only apply numResults filtering
-    if (recentHours === 0) {
-        return numResults > 0 ? lines.slice(-numResults).join('\n') : content;
-    }
+export const processMemoryContent = (content, { priority = 0, recentHours = 0, numResults = 0, stripMetadata = false }) => {
+    if (!content) return content;
+    if (!priority && !recentHours && !numResults && !stripMetadata) return content;
 
+    const lines = content.split('\n');
     const currentTime = Date.now();
-    const cutoffTime = currentTime - (recentHours * 60 * 60 * 1000);
+    const cutoffTime = recentHours > 0 ? currentTime - (recentHours * 60 * 60 * 1000) : 0;
     
-    // Walk backwards through lines until we hit an old entry
-    const filteredLines = [];
-    for (let i = lines.length - 1; i >= 0; i--) {
+    // Create array of lines with their timestamps for sorting
+    const processedLinesWithDates = [];
+    for (let i = 0; i < lines.length; i++) {
         const line = lines[i];
-        const dateMatch = line.match(/\[P\d+\]\s+(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z)/);
-        if (!dateMatch) continue;
+        const parts = line.split('|');
         
-        const timestamp = new Date(dateMatch[1]).getTime();
-        if (timestamp < cutoffTime) break; // Stop processing once we hit old entries
+        // Skip invalid lines
+        if (!parts[0]) continue;
         
-        filteredLines.unshift(line); // Add to front to maintain original order
+        // Priority check with strict validation
+        if (priority > 0) {
+            if (!isValidPriority(parts[0])) continue;
+            const memoryPriority = parseInt(parts[0]);
+            if (memoryPriority > priority) continue;
+        }
         
-        // If we have enough results, stop processing
-        if (numResults > 0 && filteredLines.length >= numResults) {
-            break;
+        // Recency check with strict ISO validation
+        if (recentHours > 0) {
+            if (!isValidISOTimestamp(parts[1])) continue;
+            const entryTime = new Date(parts[1]).getTime();
+            if (entryTime < cutoffTime) continue;
         }
+        
+        // Store the line with its timestamp for sorting
+        const timestamp = isValidISOTimestamp(parts[1]) ? new Date(parts[1]).getTime() : 0;
+        
+        // If stripMetadata is true, only keep the content part
+        const processedLine = stripMetadata && parts.length >= 3 
+            ? parts.slice(2).join('|')  // Strip metadata if requested and format is valid
+            : line;                     // Keep original line otherwise
+            
+        processedLinesWithDates.push({ line: processedLine, timestamp });
     }
-
-    return filteredLines.join('\n');
+    
+    // Sort by timestamp descending (newest first)
+    processedLinesWithDates.sort((a, b) => b.timestamp - a.timestamp);
+    
+    // Take the top N results if specified
+    const finalLines = numResults > 0
+        ? processedLinesWithDates.slice(0, numResults)
+        : processedLinesWithDates;
+    
+    // Extract just the lines and join them
+    return finalLines.map(entry => entry.line).join('\n');
 };
 
 export default {
@@ -57,12 +76,14 @@ export default {
         section: `memoryAll`,
         priority: 0,
         recentHours: 0,
-        numResults: 0
+        numResults: 0,
+        stripMetadata: false
     },
     model: 'oai-gpt4o',
 
     resolver: async (_parent, args, _contextValue, _info) => {
-        const { contextId, section = 'memoryAll', priority = 0, recentHours = 0, numResults = 0 } = args;
+        const { contextId, section = 'memoryAll', priority = 0, recentHours = 0, numResults = 0, stripMetadata = false } = args;
+        const options = { priority, recentHours, numResults, stripMetadata };
 
         // this code helps migrate old memory formats
         if (section === 'memoryLegacy') {
@@ -70,26 +91,12 @@ export default {
             return savedContext.memoryContext || "";
         }
 
-        const validSections = ['memorySelf', 'memoryDirectives', 'memoryTopics', 'memoryUser', 'memoryContext'];
+        const validSections = ['memorySelf', 'memoryDirectives', 'memoryTopics', 'memoryUser', 'memoryContext', 'memoryVersion'];
 
         if (section !== 'memoryAll') {
             if (validSections.includes(section)) {
-                let content = (getv && (await getv(`${contextId}-${section}`))) || "";
-                
-                if (section === 'memoryTopics') {
-                    if (recentHours > 0 || numResults > 0) {
-                        content = filterByRecent(content, recentHours, numResults);
-                    }
-                } else if (priority > 0 || numResults > 0) {
-                    content = filterByPriority(content, priority, numResults);
-                }
-                
-                // Only apply recency filter to memoryTopics
-                if (section === 'memoryTopics' && (recentHours > 0 || numResults > 0)) {
-                    content = filterByRecent(content, recentHours, numResults);
-                }
-                
-                return content;
+                const content = (getv && (await getv(`${contextId}-${section}`))) || "";
+                return processMemoryContent(content, options);
             }
             return "";
         }
@@ -99,19 +106,10 @@ export default {
         for (const section of validSections) {
             if (section === 'memoryContext') continue;
 
-            let content = (getv && (await getv(`${contextId}-${section}`))) || "";
-            
-            if (section === 'memoryTopics') {
-                if (recentHours > 0 || numResults > 0) {
-                    content = filterByRecent(content, recentHours, numResults);
-                }
-            } else if (priority > 0 || numResults > 0) {
-                content = filterByPriority(content, priority, numResults);
-            }
-            
-            memoryContents[section] = content;
+            const content = (getv && (await getv(`${contextId}-${section}`))) || "";
+            memoryContents[section] = processMemoryContent(content, options);
         }
-        const returnValue = JSON.stringify(memoryContents, null, 2);
-        return returnValue;
+        
+        return JSON.stringify(memoryContents, null, 2);
     }
 }

package/pathways/system/entity/memory/sys_save_memory.js

@@ -22,7 +22,7 @@ export default {
             return aiMemory;
         }
 
-        const validSections = ['memorySelf', 'memoryDirectives', 'memoryTopics', 'memoryUser'];
+        const validSections = ['memorySelf', 'memoryDirectives', 'memoryTopics', 'memoryUser', 'memoryVersion'];
 
         // Handle single section save
         if (section !== 'memoryAll') {

package/pathways/system/entity/memory/sys_search_memory.js

@@ -53,7 +53,7 @@ export default {
             result = `${result}\n\nThe last time you spoke to the user was ${new Date().toISOString()}.`;
 
         } else {
-            sectionMemory = await callPathway("sys_read_memory", {contextId: args.contextId, section: args.section}); 
+            sectionMemory = await callPathway("sys_read_memory", {contextId: args.contextId, section: args.section, stripMetadata: (args.section !== 'memoryTopics')}); 
             result = await runAllPrompts({...args, sectionMemory});
         }
 

package/pathways/system/entity/sys_entity_start.js

@@ -5,6 +5,7 @@ import logger from  '../../../lib/logger.js';
 import { chatArgsHasImageUrl } from  '../../../lib/util.js';
 import { QueueServiceClient } from '@azure/storage-queue';
 import { config } from '../../../config.js';
+import { addToolCalls, addToolResults } from './memory/shared/sys_memory_helpers.js';
 
 const connectionString = process.env.AZURE_STORAGE_CONNECTION_STRING;
 let queueClient;
@@ -86,9 +87,13 @@ export default {
             args.model = pathwayResolver.modelName;
         }
 
+        // Stuff the memory context into the chat history
+        const chatHistoryBeforeMemory = [...args.chatHistory];
+
         const memoryContext = await callPathway('sys_read_memory', { ...args, section: 'memoryContext', priority: 0, recentHours: 0, stream: false }, pathwayResolver);
         if (memoryContext) {
-            args.chatHistory.splice(-1, 0, { role: 'assistant', content: memoryContext });
+            const { toolCallId } = addToolCalls(args.chatHistory, "search memory for relevant information", "memory_lookup");
+            addToolResults(args.chatHistory, memoryContext, toolCallId);
         }
         
         let ackResponse = null;
@@ -103,15 +108,13 @@ export default {
         const fetchChatResponse = async (args, pathwayResolver) => {
             const [chatResponse, chatTitleResponse] = await Promise.all([
                 callPathway('sys_generator_quick', {...args, model: styleModel}, pathwayResolver),
-                callPathway('chat_title', { ...args, stream: false}),
+                callPathway('chat_title', { ...args, chatHistory: chatHistoryBeforeMemory, stream: false}),
             ]);
 
             title = chatTitleResponse;
 
             return chatResponse;
         };
-            
-        const { chatHistory } = args;
 
         // start fetching the default response - we may need it later
         let fetchChatResponsePromise;
@@ -125,13 +128,13 @@ export default {
             // Get tool routing response
             const toolRequiredResponse = await callPathway('sys_router_tool', { 
                 ...args,
-                chatHistory: chatHistory.slice(-4),
+                chatHistory: chatHistoryBeforeMemory.slice(-4),
                 stream: false
             });
 
             // Asynchronously manage memory for this context
             if (args.aiMemorySelfModify) {
-                callPathway('sys_memory_manager', {  ...args, stream: false })    
+                callPathway('sys_memory_manager', {  ...args, chatHistory: chatHistoryBeforeMemory, stream: false })    
                 .catch(error => logger.error(error?.message || "Error in sys_memory_manager pathway"));
             }
 

package/pathways/system/entity/sys_generator_image.js

@@ -3,7 +3,7 @@
 import { callPathway } from '../../../lib/pathwayTools.js';
 import { Prompt } from '../../../server/prompt.js';
 import logger from '../../../lib/logger.js';
-import { getUniqueId } from '../../../lib/util.js';
+import { addToolCalls, addToolResults } from './memory/shared/sys_memory_helpers.js';
 
 export default {
     prompt: [],
@@ -26,15 +26,11 @@ export default {
     timeout: 300,
 
     executePathway: async ({args, runAllPrompts, resolver}) => {
-
         const { chatHistory } = args;
-
         let pathwayResolver = resolver;
-
         const useMemory = args.useMemory || pathwayResolver.pathway.inputParameters.useMemory;
 
-        pathwayResolver.pathwayPrompt = 
-        [
+        pathwayResolver.pathwayPrompt = [
             new Prompt({ messages: [
                 {
                     "role": "system",
@@ -48,38 +44,7 @@ Instructions: As part of a conversation with the user, you have been asked to cr
             ]}),
         ];
 
-        // function to add tool_calls to the chatHistory
-        const addToolCalls= (chatHistory, imagePrompt, toolCallId) => {
-            const toolCall = {
-                "role": "assistant",
-                "tool_calls": [
-                        {
-                            "id": toolCallId,
-                            "type": "function",
-                            "function": {
-                                "arguments": JSON.stringify(imagePrompt),
-                                "name": "generate_image"
-                            }
-                        }
-                    ]
-            };
-            chatHistory.push(toolCall);
-            return chatHistory;
-        }
-
-        // function to add tool_results to the chatHistory
-        const addToolResults = (chatHistory, imageResults, toolCallId) => {
-            const toolResult = {
-                "role": "tool",
-                "content": imageResults,
-                "tool_call_id": toolCallId
-            };
-            chatHistory.push(toolResult);
-            return chatHistory;
-        }
-
         try {
-          
             // figure out what the user wants us to do
             const contextInfo = chatHistory.filter(message => message.role === "user").slice(0, -1).map(message => message.content).join("\n");
             
@@ -100,7 +65,7 @@ Instructions: As part of a conversation with the user, you have been asked to cr
                     model = "replicate-flux-1-schnell";
                 }
                 if (renderText) {
-                    return await callPathway('image_recraft', {...args, text: prompt, stream: false });
+                    return await callPathway('image_recraft', {...args, text: prompt, model, stream: false });
                 } else {
                     return await callPathway('image_flux', {...args, text: prompt, negativePrompt, numberResults, model, stream: false });
                 }
@@ -108,9 +73,8 @@ Instructions: As part of a conversation with the user, you have been asked to cr
 
             // add the tool_calls and tool_results to the chatHistory
             imageResults.forEach((imageResult, index) => {
-                const toolCallId = getUniqueId();
-                addToolCalls(chatHistory, imagePrompts[index], toolCallId);
-                addToolResults(chatHistory, imageResult, toolCallId);
+                const { toolCallId } = addToolCalls(chatHistory, imagePrompts[index], "generate_image");
+                addToolResults(chatHistory, imageResult, toolCallId, "generate_image");
             });
             
             const result = await runAllPrompts({ ...args });

package/pathways/system/entity/sys_generator_memory.js

@@ -1,4 +1,5 @@
 import { callPathway } from '../../../lib/pathwayTools.js';
+import { addToolCalls, addToolResults } from './memory/shared/sys_memory_helpers.js';
 
 export default {
     prompt:
@@ -19,7 +20,8 @@ export default {
 
         const memoryContext = await callPathway('sys_search_memory', { ...args, section: 'memoryAll', updateContext: true });
         if (memoryContext) {
-            args.chatHistory.splice(-1, 0, { role: 'assistant', content: memoryContext });
+            const {toolCallId} = addToolCalls(args.chatHistory, "search memory for relevant information", "memory_lookup");
+            addToolResults(args.chatHistory, memoryContext, toolCallId);
         }
 
         let result;

package/pathways/system/entity/sys_generator_reasoning.js

@@ -5,7 +5,7 @@ export default {
     prompt:
         [
             new Prompt({ messages: [
-                {"role": "system", "content": `{{renderTemplate AI_COMMON_INSTRUCTIONS}}\n{{renderTemplate AI_EXPERTISE}}\n{{renderTemplate AI_MEMORY}}\nYou are the AI subsystem responsible for advanced, step-by-step reasoning. Use all of the information in your memory and the chat history to reason about the user's request and provide a correct and accurate response. The information in your chat history may be more current than your knowledge cutoff and has been verified by other subsystems so prioritize it over your internal knowledge.\n{{renderTemplate AI_MEMORY_INSTRUCTIONS}}\n{{renderTemplate AI_DATETIME}}`},
+                {"role": "system", "content": `Formatting re-enabled\n{{renderTemplate AI_COMMON_INSTRUCTIONS}}\n{{renderTemplate AI_EXPERTISE}}\n{{renderTemplate AI_MEMORY}}\nYou are the AI subsystem responsible for advanced, step-by-step reasoning. Use all of the information in your memory and the chat history to reason about the user's request and provide a correct and accurate response. The information in your chat history may be more current than your knowledge cutoff and has been verified by other subsystems so prioritize it over your internal knowledge.\n{{renderTemplate AI_MEMORY_INSTRUCTIONS}}\n{{renderTemplate AI_DATETIME}}`},
                 "{{chatHistory}}",
             ]}),
         ],

package/pathways/system/entity/sys_router_tool.js

@@ -21,7 +21,7 @@ Available tools and their specific use cases:
 
 2. Document: Access user's personal document index. Use for user-specific uploaded information. If user refers vaguely to "this document/file/article" without context, use this tool to search the personal index.
 
-3. Memory: Access to your memory index. Use to recall any information that you may have stored in your memory that you don't currently see elsewhere in your context.
+3. Memory: Read access to your memory index. Use to recall any information that you may have stored in your memory that you don't currently see elsewhere in your context. If you can answer from your context, don't use this tool. Don't use to make changes to your memory - that will happen naturally.
 
 4. Write: Engage for any task related to composing, editing, or refining written content. This includes articles, essays, scripts, or any form of textual creation or modification. If you need to search for information or look at a document first, use the Search or Document tools. This tool is just to create or modify content.
 
@@ -52,13 +52,12 @@ Tool Selection Guidelines:
 
 Decision Output:
 If you decide to use a tool, return a JSON object in this format:
-{"toolRequired": true, "toolFunction": "toolName", "toolMessage": "message to the user to wait a moment while you work", "toolReason": "detailed explanation of why this tool was chosen"}
+{"toolRequired": true, "toolFunction": "toolName", "toolMessage": "message to the user that you are taking an action", "toolReason": "detailed explanation of why this tool was chosen"}
 
 toolMessage Guidelines:
-- The message is a filler message to the user to let them know you're working on their request.
 - The message should be consistent in style and tone with the rest of your responses in the conversation history.
 - The message should be brief and conversational and flow naturally with the conversation history.
-- The message should not refer to the tool directly, but rather what you're trying to accomplish. E.g. for the memory tool, the message would be something like "Let me think about that for a moment..." or "I'm trying to remember...", etc.
+- The message should not refer to the tool use directly, but rather what you're trying to do.
 
 If no tool is required, return:
 {"toolRequired": false, "toolReason": "explanation of why no tool was necessary"}