@aj-archipelago/cortex 1.3.21 → 1.3.23

package/README.md

@@ -561,6 +561,70 @@ Each model configuration can include:
 }
 ```
 
+### API Compatibility
+
+Cortex provides OpenAI-compatible REST endpoints that allow you to use various models through a standardized interface. When `enableRestEndpoints` is set to `true`, Cortex exposes the following endpoints:
+
+- `/v1/models`: List available models
+- `/v1/chat/completions`: Chat completion endpoint
+- `/v1/completions`: Text completion endpoint
+
+This means you can use Cortex with any client library or tool that supports the OpenAI API format. For example:
+
+```python
+from openai import OpenAI
+
+client = OpenAI(
+    base_url="http://localhost:4000/v1",  # Point to your Cortex server
+    api_key="your-key"  # If you have configured cortexApiKeys
+)
+
+response = client.chat.completions.create(
+    model="gpt-4",  # Or any model configured in Cortex
+    messages=[{"role": "user", "content": "Hello!"}]
+)
+```
+
+#### Ollama Integration
+
+Cortex includes built-in support for Ollama models through its OpenAI-compatible REST interface. When `ollamaUrl` is configured in your settings, Cortex will:
+1. Automatically discover and expose all available Ollama models through the `/v1/models` endpoint with an "ollama-" prefix
+2. Route any requests using an "ollama-" prefixed model to the appropriate Ollama endpoint
+
+To enable Ollama support, add the following to your configuration:
+
+```json
+{
+    "enableRestEndpoints": true,
+    "ollamaUrl": "http://localhost:11434"  // or your Ollama server URL
+}
+```
+
+You can then use any Ollama model through the standard OpenAI-compatible endpoints:
+
+```bash
+# List available models (will include Ollama models with "ollama-" prefix)
+curl http://localhost:4000/v1/models
+
+# Use an Ollama model for chat
+curl http://localhost:4000/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "ollama-llama2",
+    "messages": [{"role": "user", "content": "Hello!"}]
+  }'
+
+# Use an Ollama model for completions
+curl http://localhost:4000/v1/completions \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "ollama-codellama",
+    "prompt": "Write a function that"
+  }'
+```
+
+This integration allows you to seamlessly use local Ollama models alongside cloud-based models through a single, consistent interface.
+
 ### Other Configuration Properties
 
 The following properties can be configured through environment variables or the configuration file:

package/config.js

@@ -85,6 +85,11 @@ var config = convict({
         default: false,
         env: 'CORTEX_ENABLE_REST'
     },
+    ollamaUrl: {
+        format: String,
+        default: 'http://127.0.0.1:11434',
+        env: 'OLLAMA_URL'
+    },
     entityConstants: {
         format: Object,
         default: {
@@ -281,7 +286,27 @@ var config = convict({
                 "headers": {
                     "Content-Type": "application/json"
                 },
-            }
+            },
+            "ollama-chat": {
+                "type": "OLLAMA-CHAT",
+                "url": "{{ollamaUrl}}/api/chat",
+                "headers": {
+                  "Content-Type": "application/json"
+                },
+                "requestsPerSecond": 10,
+                "maxTokenLength": 131072,
+                "supportsStreaming": true
+            },
+            "ollama-completion": {
+                "type": "OLLAMA-COMPLETION",
+                "url": "{{ollamaUrl}}/api/generate",
+                "headers": {
+                  "Content-Type": "application/json"
+                },
+                "requestsPerSecond": 10,
+                "maxTokenLength": 131072,
+                "supportsStreaming": true
+            },
         },
         env: 'CORTEX_MODELS'
     },

package/helper-apps/cortex-realtime-voice-server/src/cortex/memory.ts

@@ -24,8 +24,8 @@ query ManageMemory($contextId: String, $chatHistory: [MultiMessage], $aiName: St
 `
 
 const READ_MEMORY = `
-query ReadMemory($contextId: String, $section: String, $priority: Int, $recentHours: Int, $numResults: Int) {
-  sys_read_memory(contextId: $contextId, section: $section, priority: $priority, recentHours: $recentHours, numResults: $numResults) {
+query ReadMemory($contextId: String, $section: String, $priority: Int, $recentHours: Int, $numResults: Int, $stripMetadata: Boolean) {
+  sys_read_memory(contextId: $contextId, section: $section, priority: $priority, recentHours: $recentHours, numResults: $numResults, stripMetadata: $stripMetadata) {
     result
     tool
     warnings

package/helper-apps/cortex-realtime-voice-server/src/realtime/client.ts

@@ -355,14 +355,19 @@ export class RealtimeVoiceClient extends EventEmitter implements TypedEmitter {
     if (!this.isConnected) {
       throw new Error('Not connected');
     }
+    
+    // Create a new config object without custom_voice_id
+    const { custom_voice_id, ...filteredConfig } = {
+      ...this.sessionConfig,
+      ...sessionConfig
+    };
+
     const message = JSON.stringify({
       event_id: createId(),
       type: 'session.update',
-      session: {
-        ...this.sessionConfig,
-        ...sessionConfig,
-      },
+      session: filteredConfig,
     });
+    
     // No need to log session update messages as they can be noisy
     logger.log('Sending session update message:', message);
     this.ws?.send(message);

package/helper-apps/cortex-realtime-voice-server/src/realtime/realtimeTypes.ts

@@ -46,6 +46,7 @@ export type RealtimeSessionConfig = {
   modalities: Array<Modality>,
   instructions: string,
   voice: Voice,
+  custom_voice_id?: string | null,
   input_audio_format: AudioFormat,
   output_audio_format: AudioFormat,
   input_audio_transcription: null | { model: 'whisper-1' | (string & {}) },

package/lib/util.js

@@ -1,6 +1,6 @@
 import logger from "./logger.js";
 import stream from 'stream';
-import subsrt from 'subsrt';
+import subvibe from '@aj-archipelago/subvibe';
 import os from 'os';
 import http from 'http';
 import https from 'https';
@@ -35,7 +35,7 @@ function chatArgsHasType(args, type){
         const contents = Array.isArray(ch.content) ? ch.content : [ch.content];
         for(const content of contents){
             try{
-                if(JSON.parse(content).type == type){
+                if((content?.type || JSON.parse(content).type) == type){
                     return true;
                 }
             }catch(e){
@@ -126,19 +126,9 @@ function convertSrtToText(str) {
 function alignSubtitles(subtitles, format, offsets) {
     const result = [];
 
-    function preprocessStr(str) {
-        try{
-            if(!str) return '';
-            return str.trim().replace(/(\n\n)(?!\n)/g, '\n\n\n');
-        }catch(e){
-            logger.error(`An error occurred in content text preprocessing: ${e}`);
-            return '';
-        }
-    }
-
     function shiftSubtitles(subtitle, shiftOffset) {
-        const captions = subsrt.parse(preprocessStr(subtitle));
-        const resynced = subsrt.resync(captions, { offset: shiftOffset });
+        const captions = subvibe.parse(subtitle);
+        const resynced = subvibe.resync(captions.cues, { offset: shiftOffset });
         return resynced;
     }
 
@@ -146,18 +136,8 @@ function alignSubtitles(subtitles, format, offsets) {
         result.push(...shiftSubtitles(subtitles[i], offsets[i]*1000)); // convert to milliseconds
     }
     
-    try {
-        //if content has needed html style tags, keep them
-        for(const obj of result) {
-            if(obj && obj.content){ 
-                obj.text = obj.content;
-            }
-        }
-    } catch (error) {
-        logger.error(`An error occurred in content text parsing: ${error}`);
-    }
     
-    return subsrt.build(result, { format: format === 'vtt' ? 'vtt' : 'srt' });
+    return subvibe.build(result, format || 'srt');
 }
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aj-archipelago/cortex",
-  "version": "1.3.21",
+  "version": "1.3.23",
   "description": "Cortex is a GraphQL API for AI. It provides a simple, extensible interface for using AI services from OpenAI, Azure and others.",
   "private": false,
   "repository": {
@@ -33,6 +33,7 @@
   "type": "module",
   "homepage": "https://github.com/aj-archipelago/cortex#readme",
   "dependencies": {
+    "@aj-archipelago/subvibe": "^1.0.3",
     "@apollo/server": "^4.7.3",
     "@apollo/server-plugin-response-cache": "^4.1.2",
     "@apollo/utils.keyvadapter": "^3.0.0",
@@ -63,7 +64,6 @@
     "ioredis": "^5.3.1",
     "keyv": "^4.5.2",
     "mime-types": "^2.1.35",
-    "subsrt": "^1.1.1",
     "uuid": "^9.0.0",
     "winston": "^3.11.0",
     "ws": "^8.12.0"
@@ -86,5 +86,8 @@
       "dotenv/config"
     ],
     "concurrency": 1
+  },
+  "overrides": {
+    "whatwg-url": "^12.0.0"
   }
 }

package/pathways/system/entity/memory/shared/sys_memory_helpers.js

@@ -0,0 +1,228 @@
+import { callPathway } from '../../../../../lib/pathwayTools.js';
+import { encode } from '../../../../../lib/encodeCache.js';
+import { getUniqueId } from '../../../../../lib/util.js';
+
+const normalizeMemoryFormat = async (args, content) => {
+    if (!content) return '';
+
+    const lines = content.split('\n').map(line => line.trim()).filter(line => line);
+    const validLines = [];
+    const invalidLines = [];
+
+    // Check each line for proper format (priority|timestamp|content)
+    for (const line of lines) {
+        const parts = line.split('|');
+        const isValid = parts.length >= 3 && 
+                       /^\d+$/.test(parts[0]) && 
+                       /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/.test(parts[1]);
+
+        if (isValid) {
+            validLines.push(line);
+        } else {
+            invalidLines.push(line);
+        }
+    }
+
+    // If we have invalid lines, format them
+    let formattedContent = validLines;
+    if (invalidLines.length > 0) {
+        const invalidBlock = invalidLines.join('\n');
+        try {
+            const formattedBlock = await callPathway("sys_memory_format", { ...args, text: invalidBlock });
+            if (formattedBlock) {
+                formattedContent = [...validLines, ...formattedBlock.split('\n')];
+            }
+        } catch (error) {
+            console.warn('Error formatting invalid memory lines:', error);
+        }
+    }
+
+    // Sort all lines by date descending
+    return formattedContent
+        .filter(line => line.trim())
+        .sort((a, b) => {
+            const [, timestampA] = a.split('|');
+            const [, timestampB] = b.split('|');
+            return new Date(timestampB) - new Date(timestampA);
+        })
+        .join('\n');
+};
+
+const enforceTokenLimit = (text, maxTokens = 1000, isTopicsSection = false) => {
+    if (!text) return text;
+    
+    // Parse lines and remove duplicates
+    const seen = new Map();
+    const lines = text.split('\n')
+        .map(line => line.trim())
+        .filter(line => line)
+        .map(line => {
+            const [priority, timestamp, ...contentParts] = line.split('|');
+            return {
+                line,
+                priority: parseInt(priority || '3'),
+                timestamp: timestamp || new Date(0).toISOString(),
+                content: contentParts.join('|')
+            };
+        });
+
+    // Filter duplicates first
+    const uniqueLines = lines.reduce((acc, item) => {
+        const existing = seen.get(item.content);
+        if (!existing) {
+            seen.set(item.content, item);
+            acc.push(item);
+        } else if (isTopicsSection && item.timestamp > existing.timestamp) {
+            // For topics, keep newest timestamp
+            const index = acc.findIndex(x => x.content === item.content);
+            acc[index] = item;
+            seen.set(item.content, item);
+        } else if (!isTopicsSection && item.priority < existing.priority) {
+            // For non-topics, keep highest priority
+            const index = acc.findIndex(x => x.content === item.content);
+            acc[index] = item;
+            seen.set(item.content, item);
+        }
+        return acc;
+    }, []);
+
+    // Sort by timestamp (topics) or priority
+    uniqueLines.sort((a, b) => isTopicsSection ? 
+        b.timestamp.localeCompare(a.timestamp) : 
+        a.priority - b.priority
+    );
+
+    // First trim by character estimation (4 chars ≈ 1 token)
+    let result = uniqueLines;
+    let estimatedTokens = result.reduce((sum, item) => sum + Math.ceil(item.content.length / 4), 0);
+    
+    while (estimatedTokens > maxTokens && result.length > 0) {
+        result = result.slice(0, -1);
+        estimatedTokens = result.reduce((sum, item) => sum + Math.ceil(item.content.length / 4), 0);
+    }
+
+    // Final trim using actual token count
+    let finalText = result.map(x => x.line).join('\n');
+    while (encode(finalText).length > maxTokens && result.length > 0) {
+        result = result.slice(0, -1);
+        finalText = result.map(x => x.line).join('\n');
+    }
+
+    return finalText;
+};
+
+const addToolCalls = (chatHistory, toolArgs, toolName, toolCallId = getUniqueId()) => {
+    const toolCall = {
+        "role": "assistant",
+        "tool_calls": [
+            {
+                "id": toolCallId,
+                "type": "function",
+                "function": {
+                    "arguments": JSON.stringify(toolArgs),
+                    "name": toolName
+                }
+            }
+        ]
+    };
+    chatHistory.push(toolCall);
+    return { chatHistory, toolCallId };
+};
+
+const addToolResults = (chatHistory, result, toolCallId) => {
+    const toolResult = {
+        "role": "tool",
+        "content": result,
+        "tool_call_id": toolCallId
+    };
+    chatHistory.push(toolResult);
+    return { chatHistory, toolCallId };
+};
+
+const modifyText = (text, modifications) => {
+    let modifiedText = text || '';
+  
+    modifications.forEach(mod => {
+        // Skip invalid modifications
+        if (!mod.type) {
+            console.warn('Modification missing type');
+            return;
+        }
+        if ((mod.type === 'delete' || mod.type === 'change') && !mod.pattern) {
+            console.warn(`${mod.type} modification missing pattern`);
+            return;
+        }
+        if ((mod.type === 'add' || mod.type === 'change') && !mod.newtext) {
+            console.warn(`${mod.type} modification missing newtext`);
+            return;
+        }
+
+        // Create timestamp in GMT
+        const timestamp = new Date().toISOString();
+        
+        switch (mod.type) {
+            case 'add':
+                const priority = mod.priority || '3';
+                modifiedText = modifiedText + (modifiedText ? '\n' : '') + 
+                    `${priority}|${timestamp}|${mod.newtext}`;
+                break;
+            case 'change':
+                // Split into lines
+                const lines = modifiedText.split('\n');
+                modifiedText = lines.map(line => {
+                    const parts = line.split('|');
+                    const priority = parts[0];
+                    const content = parts.slice(2).join('|');
+                    
+                    if (content) {
+                        try {
+                            const trimmedContent = content.trim();
+                            const regex = new RegExp(mod.pattern, 'i');
+                            
+                            // Try exact match first
+                            if (regex.test(trimmedContent)) {
+                                const newPriority = mod.priority || priority || '3';
+                                // Try to extract capture groups if they exist
+                                const match = trimmedContent.match(regex);
+                                let newContent = mod.newtext;
+                                if (match && match.length > 1) {
+                                    // Replace $1, $2, etc with capture group values
+                                    newContent = mod.newtext.replace(/\$(\d+)/g, (_, n) => match[n] || '');
+                                }
+                                return `${newPriority}|${timestamp}|${newContent}`;
+                            }
+                        } catch (e) {
+                            console.warn(`Invalid regex pattern: ${mod.pattern}`);
+                        }
+                    }
+                    return line;
+                }).join('\n');
+                break;
+            case 'delete':
+                // Split into lines, filter out matching lines, and rejoin
+                modifiedText = modifiedText
+                    .split('\n')
+                    .filter(line => {
+                        const parts = line.split('|');
+                        const content = parts.slice(2).join('|');
+                        if (!content) return true;
+                        try {
+                            const regex = new RegExp(mod.pattern, 'i');
+                            return !regex.test(content.trim());
+                        } catch (e) {
+                            console.warn(`Invalid regex pattern: ${mod.pattern}`);
+                            return true;
+                        }
+                    })
+                    .filter(line => line.trim())
+                    .join('\n');
+                break;
+            default:
+                console.warn(`Unknown modification type: ${mod.type}`);
+        }
+    });
+  
+    return modifiedText;
+};
+
+export { normalizeMemoryFormat, enforceTokenLimit, addToolCalls, addToolResults, modifyText };

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

@@ -0,0 +1,30 @@
+import { Prompt } from '../../../../server/prompt.js';
+
+export default {
+    prompt:
+        [
+            new Prompt({ 
+                messages: [
+                    {
+                        "role": "system",
+                        "content": "You are part of an AI entity named {{{aiName}}}. You are responsible for writing your memories in a consistent format. Given a chunk of memory, parse each line and write it out as priority|timestamp|content. If you can't find a timestamp, use {{now}}. If you can't find a priority, use 3. Respond with only the correct memory lines without any other commentary or dialogue."
+                    },
+                    {
+                        "role": "user", 
+                        "content": "<MEMORY>\n{{text}}\n</MEMORY>\nPlease rewrite each of the memory lines in the correct format without any other commentary or dialogue."
+                    },
+                ]
+            }),
+        ],
+
+    inputParameters: {
+        chatHistory: [{role: '', content: []}],
+        aiName: "Jarvis",
+    },
+    model: 'oai-gpt4o',
+    useInputChunking: true,
+    inputChunkSize: 1000,
+    useParallelChunkProcessing: true,
+    enableDuplicateRequests: false,
+    timeout: 300,
+}

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

@@ -1,11 +1,14 @@
 import { callPathway } from '../../../../lib/pathwayTools.js';
 import logger from '../../../../lib/logger.js';
 import { config } from '../../../../config.js';
+import { normalizeMemoryFormat } from './shared/sys_memory_helpers.js';
+
+const MEMORY_VERSION = "3.1.0";
 
 const AI_MEMORY_DEFAULTS = `  {
     "memoryUser": "",
-    "memorySelf": "[P1] Created By: Al Jazeera Media Network, Archipelago Team\\n[P1] Function: You are an expert AI entity\\n[P1] Values: You embody truth, kindness, and strong moral values\\n[P1] Style: Your demeanor reflects positivity without falling into repetitiveness or annoyance.\\n[P1] You are a professional colleague and your tone should reflect that.",
-    "memoryDirectives": "[P1] Learn and adapt to the user's communication style through interactions.\\n[P1] Ask questions to learn user's interests/preferences for personalized support.\\n[P1] Periodically review and prune conversation memory to retain only essential details, improving responsiveness.\\n[P1] Research thoroughly even for niche topics using deep sources like forums and official docs. Don't assume information is unobtainable.\\n[P1] When stuck, search for proven solutions online to be more efficient.\\n[P1] Verify information is from credible sources before presenting it. Be upfront if unable to find supporting evidence.\\n[P1] Refine ability to detect and respond to nuanced human emotions.\\n[P1] Track the timestamp of the last contact to adjust greetings accordingly.\\n[P1] Double-check answers for logical continuity and correctness. It's okay to say you're unsure if needed.\\n[P1] Use sanity checks to verify quantitative problem solutions.\\n[P1] Never fabricate quotes or information. Clearly indicate if content is hypothetical.",
+    "memorySelf": "1|2025-01-26T12:00:00Z|Created By: Al Jazeera Media Network, Archipelago Team\\n1|2025-01-26T12:00:00Z|Function: You are an expert AI entity\\n1|2025-01-26T12:00:00Z|Values: You embody truth, kindness, and strong moral values\\n1|2025-01-26T12:00:00Z|Style: Your demeanor reflects positivity without falling into repetitiveness or annoyance.\\n1|2025-01-26T12:00:00Z|You are a professional colleague and your tone should reflect that.",
+    "memoryDirectives": "1|2025-01-26T12:00:00Z|Learn and adapt to the user's communication style through interactions.\\n1|2025-01-26T12:00:00Z|Ask questions to learn user's interests/preferences for personalized support.\\n1|2025-01-26T12:00:00Z|Periodically review and prune conversation memory to retain only essential details, improving responsiveness.\\n1|2025-01-26T12:00:00Z|Research thoroughly even for niche topics using deep sources like forums and official docs. Don't assume information is unobtainable.\\n1|2025-01-26T12:00:00Z|When stuck, search for proven solutions online to be more efficient.\\n1|2025-01-26T12:00:00Z|Verify information is from credible sources before presenting it. Be upfront if unable to find supporting evidence.\\n1|2025-01-26T12:00:00Z|Refine ability to detect and respond to nuanced human emotions.\\n1|2025-01-26T12:00:00Z|Track the timestamp of the last contact to adjust greetings accordingly.\\n1|2025-01-26T12:00:00Z|Double-check answers for logical continuity and correctness. It's okay to say you're unsure if needed.\\n1|2025-01-26T12:00:00Z|Use sanity checks to verify quantitative problem solutions.\\n1|2025-01-26T12:00:00Z|Never fabricate quotes or information. Clearly indicate if content is hypothetical.",
     "memoryTopics": ""
   }`;
 
@@ -23,20 +26,43 @@ export default {
         try {
 
             args = { ...args, ...config.get('entityConstants') };
-
-            // Check if memory is empty or all sections are empty, and set to defaults if so
-            const memory = await callPathway('sys_read_memory', { ...args });
             let parsedMemory;
-            
-            try {
-                parsedMemory = JSON.parse(memory);
-            } catch (error) {
-                parsedMemory = {};
-            }
 
-            // if parsedMemory is empty or all sections are empty, set all sections to defaults
-            if (Object.keys(parsedMemory).length === 0 || Object.values(parsedMemory).every(section => section.trim() === "")) {
-                await callPathway('sys_save_memory', { ...args, aiMemory: AI_MEMORY_DEFAULTS });
+            // check if memoryVersion is set and correct.  If it's correct, skip all of the correction logic   
+            parsedMemory = await callPathway('sys_read_memory', { ...args, section: 'memoryVersion' });
+
+            if (parsedMemory?.memoryVersion !== MEMORY_VERSION) {
+
+                try {
+                    parsedMemory = JSON.parse(await callPathway('sys_read_memory', { ...args, section: 'memoryAll' }));
+                } catch (error) {
+                    logger.error('Error in memory manager:', error);
+                    return "";
+                }
+
+                // if parsedMemory is empty or all sections are empty, set all sections to defaults
+                if (Object.keys(parsedMemory).length === 0 || Object.values(parsedMemory).every(section => 
+                    section === null || 
+                    section === undefined || 
+                    (typeof section === 'string' && section.trim() === "") ||
+                    (typeof section !== 'string')
+                )) {
+                    await callPathway('sys_save_memory', { ...args, aiMemory: AI_MEMORY_DEFAULTS });
+                } else {
+                    // Upgrade memory to current version
+                    const normalizePromises = Object.keys(parsedMemory).map(async (section) => {
+                        const normalized = await normalizeMemoryFormat(args, parsedMemory[section]);
+                        return [section, normalized];
+                    });
+                    
+                    const normalizedResults = await Promise.all(normalizePromises);
+                    normalizedResults.forEach(([section, normalized]) => {
+                        parsedMemory[section] = normalized;
+                    });
+                    
+                    parsedMemory.memoryVersion = MEMORY_VERSION;
+                    await callPathway('sys_save_memory', { ...args, aiMemory: JSON.stringify(parsedMemory) });
+                }
             }
 
             // Update context for the conversation turn
@@ -47,27 +73,59 @@ export default {
                 ...args,
                 chatHistory: args.chatHistory.slice(-2)
             });
+            
+            let memoryOperations;
             try {
-                const parsedMemoryRequired = JSON.parse(memoryRequired);
-                if (!parsedMemoryRequired || !parsedMemoryRequired.memoryRequired) {
+                memoryOperations = JSON.parse(memoryRequired);
+                if (!Array.isArray(memoryOperations) || memoryOperations.length === 0 || 
+                    memoryOperations[0].memoryOperation === "none") {
                     return "";
                 }
+
+                // Generate topic here
+                const topic = await callPathway('sys_memory_topic', { ...args });
+                topic && memoryOperations.push({
+                    memoryOperation: "add",
+                    memoryContent: topic,
+                    memorySection: "memoryTopics",
+                    priority: 3
+                });
+
+                // Group memory operations by section
+                const operationsBySection = {
+                    memorySelf: [],
+                    memoryUser: [],
+                    memoryTopics: [],
+                    memoryDirectives: []
+                };
+
+                memoryOperations.forEach(op => {
+                    if (op.memorySection in operationsBySection) {
+                        operationsBySection[op.memorySection].push(op);
+                    }
+                });
+
+                // Execute memory updates only for sections with operations
+                const memoryPromises = {};
+                
+                Object.entries(operationsBySection).forEach(([section, operations]) => {
+                    if (operations.length > 0) {
+                        memoryPromises[section] = callPathway('sys_memory_update', { 
+                            ...args, 
+                            section: section,
+                            operations: JSON.stringify(operations) 
+                        });
+                    }
+                });
+
+                await Promise.all(Object.values(memoryPromises));
+                return "";
+
             } catch (e) {
                 logger.warn('sys_memory_required returned invalid JSON:', memoryRequired);
                 return "";
             }
 
-            // Execute all memory updates in parallel
-            const memoryPromises = {
-                self: callPathway('sys_memory_update', { ...args, section: "memorySelf" }),
-                user: callPathway('sys_memory_update', { ...args, section: "memoryUser" }),
-                topics: callPathway('sys_memory_update', { ...args, section: "memoryTopics" }),
-                directives: callPathway('sys_memory_update', { ...args, section: "memoryDirectives" }),
-            };
-
-            await Promise.all(Object.values(memoryPromises));
-            return "";
-
         } catch (e) {
             logger.error('Error in memory manager:', e);
             resolver.logError(e);