@aj-archipelago/cortex 1.4.24 → 1.4.26

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aj-archipelago/cortex",
-  "version": "1.4.24",
+  "version": "1.4.26",
   "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": {

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

@@ -26,6 +26,10 @@ export default {
     timeout: 300,
     executePathway: async ({args, resolver}) => {
         try {
+            // Skip if memory is disabled
+            if (args.useMemory === false) {
+                return "";
+            }
 
             args = { ...args, ...config.get('entityConstants') };
             let parsedMemory;

package/pathways/system/entity/sys_entity_agent.js

@@ -60,6 +60,7 @@ export default {
     useInputChunking: false,
     enableDuplicateRequests: false,
     useSingleTokenStream: false,
+    manageTokenLength: false, // Agentic models handle context management themselves
     inputParameters: {
         privateData: false,    
         chatHistory: [{role: '', content: []}],
@@ -452,7 +453,11 @@ export default {
         
         const entityConfig = loadEntityConfig(entityId);
         const { entityTools, entityToolsOpenAiFormat } = getToolsForEntity(entityConfig);
-        const { useMemory: entityUseMemory = true, name: entityName, instructions: entityInstructions } = entityConfig || {};
+        const { name: entityName, instructions: entityInstructions } = entityConfig || {};
+        
+        // Determine useMemory: entityConfig.useMemory === false is a hard disable (entity can't use memory)
+        // Otherwise args.useMemory can disable it, default true
+        args.useMemory = entityConfig?.useMemory === false ? false : (args.useMemory ?? true);
 
         // Initialize chat history if needed
         if (!args.chatHistory || args.chatHistory.length === 0) {
@@ -488,7 +493,7 @@ export default {
 
         // Kick off the memory lookup required pathway in parallel - this takes like 500ms so we want to start it early
         let memoryLookupRequiredPromise = null;
-        if (entityUseMemory) {
+        if (args.useMemory) {
             const chatHistoryLastTurn = args.chatHistory.slice(-2);
             const chatHistorySizeOk = (JSON.stringify(chatHistoryLastTurn).length < 5000);
             if (chatHistorySizeOk) {
@@ -512,7 +517,6 @@ export default {
             entityId,
             entityTools,
             entityToolsOpenAiFormat,
-            entityUseMemory,
             entityInstructions,
             voiceResponse,
             aiMemorySelfModify,
@@ -524,7 +528,7 @@ export default {
 
         const promptPrefix = '';
 
-        const memoryTemplates = entityUseMemory ? 
+        const memoryTemplates = args.useMemory ? 
             `{{renderTemplate AI_MEMORY_INSTRUCTIONS}}\n\n{{renderTemplate AI_MEMORY}}\n\n{{renderTemplate AI_MEMORY_CONTEXT}}\n\n` : '';
 
         const instructionTemplates = entityInstructions ? (entityInstructions + '\n\n') : `{{renderTemplate AI_COMMON_INSTRUCTIONS}}\n\n{{renderTemplate AI_EXPERTISE}}\n\n`;
@@ -560,7 +564,7 @@ export default {
         const truncatedChatHistory = resolver.modelExecutor.plugin.truncateMessagesToTargetLength(args.chatHistory, null, 1000);
       
         // Asynchronously manage memory for this context
-        if (args.aiMemorySelfModify && entityUseMemory) {
+        if (args.aiMemorySelfModify && args.useMemory) {
             callPathway('sys_memory_manager', {  ...args, chatHistory: truncatedChatHistory, stream: false })    
             .catch(error => logger.error(error?.message || "Error in sys_memory_manager pathway"));
         }

package/pathways/system/entity/tools/sys_tool_store_memory.js

@@ -52,8 +52,7 @@ export default {
 
     executePathway: async ({args, runAllPrompts, resolver}) => {
         // Check if memory is enabled for this entity
-        const useMemory = args.entityUseMemory !== undefined ? args.entityUseMemory : args.useMemory;
-        if (useMemory === false) {
+        if (args.useMemory === false) {
             return JSON.stringify({ 
                 error: 'Memory storage is disabled for this entity. Cannot store memories when useMemory is false.' 
             });

package/server/pathwayResolver.js

@@ -404,38 +404,45 @@ class PathwayResolver {
         }
 
         // Get saved context from contextId or change contextId if needed
-        const { contextId } = args;
+        const { contextId, useMemory } = args;
         this.savedContextId = contextId ? contextId : uuidv4();
         
+        // Check if memory is enabled (default true for backward compatibility)
+        const memoryEnabled = useMemory !== false;
+        
         const loadMemory = async () => {
             try {
-                // Load saved context and core memory if it exists
-                const [savedContext, memorySelf, memoryDirectives, memoryTopics, memoryUser, memoryContext] = await Promise.all([
-                    (getvWithDoubleDecryption && await getvWithDoubleDecryption(this.savedContextId, this.args?.contextKey)) || {},
-                    callPathway('sys_read_memory', { contextId: this.savedContextId, section: 'memorySelf', priority: 1, stripMetadata: true, contextKey: this.args?.contextKey }),
-                    callPathway('sys_read_memory', { contextId: this.savedContextId, section: 'memoryDirectives', priority: 1, stripMetadata: true, contextKey: this.args?.contextKey }),
-                    callPathway('sys_read_memory', { contextId: this.savedContextId, section: 'memoryTopics', priority: 0, numResults: 10, contextKey: this.args?.contextKey }),
-                    callPathway('sys_read_memory', { contextId: this.savedContextId, section: 'memoryUser', priority: 1, stripMetadata: true, contextKey: this.args?.contextKey }),
-                    callPathway('sys_read_memory', { contextId: this.savedContextId, section: 'memoryContext', priority: 0, contextKey: this.args?.contextKey }),
-                ]).catch(error => {
-                    this.logError(`Failed to load memory: ${error.message}`);
-                    return [{},'','','','',''];
-                });
+                // Always load savedContext (legacy feature)
+                this.savedContext = (getvWithDoubleDecryption && await getvWithDoubleDecryption(this.savedContextId, this.args?.contextKey)) || {};
+                this.initialState = { savedContext: this.savedContext };
+                
+                // Only load memory* sections if memory is enabled
+                if (memoryEnabled) {
+                    const [memorySelf, memoryDirectives, memoryTopics, memoryUser, memoryContext] = await Promise.all([
+                        callPathway('sys_read_memory', { contextId: this.savedContextId, section: 'memorySelf', priority: 1, stripMetadata: true, contextKey: this.args?.contextKey }),
+                        callPathway('sys_read_memory', { contextId: this.savedContextId, section: 'memoryDirectives', priority: 1, stripMetadata: true, contextKey: this.args?.contextKey }),
+                        callPathway('sys_read_memory', { contextId: this.savedContextId, section: 'memoryTopics', priority: 0, numResults: 10, contextKey: this.args?.contextKey }),
+                        callPathway('sys_read_memory', { contextId: this.savedContextId, section: 'memoryUser', priority: 1, stripMetadata: true, contextKey: this.args?.contextKey }),
+                        callPathway('sys_read_memory', { contextId: this.savedContextId, section: 'memoryContext', priority: 0, contextKey: this.args?.contextKey }),
+                    ]).catch(error => {
+                        this.logError(`Failed to load memory: ${error.message}`);
+                        return ['','','','',''];
+                    });
 
-                this.savedContext = savedContext;
-                this.memorySelf = memorySelf || '';
-                this.memoryDirectives = memoryDirectives || '';
-                this.memoryTopics = memoryTopics || '';
-                this.memoryUser = memoryUser || '';
-                this.memoryContext = memoryContext || '';
-
-                // Store initial state for comparison
-                this.initialState = {
-                    savedContext: this.savedContext,
-                };
+                    this.memorySelf = memorySelf || '';
+                    this.memoryDirectives = memoryDirectives || '';
+                    this.memoryTopics = memoryTopics || '';
+                    this.memoryUser = memoryUser || '';
+                    this.memoryContext = memoryContext || '';
+                } else {
+                    this.memorySelf = '';
+                    this.memoryDirectives = '';
+                    this.memoryTopics = '';
+                    this.memoryUser = '';
+                    this.memoryContext = '';
+                }
             } catch (error) {
                 this.logError(`Error in loadMemory: ${error.message}`);
-                // Set default values in case of error
                 this.savedContext = {};
                 this.memorySelf = '';
                 this.memoryDirectives = '';
@@ -447,6 +454,7 @@ class PathwayResolver {
         };
 
         const saveChangedMemory = async () => {
+            // Always save savedContext (legacy feature, not governed by useMemory)
             this.savedContextId = this.savedContextId || uuidv4();
             
             const currentState = {

package/server/plugins/claude3VertexPlugin.js

@@ -576,9 +576,16 @@ class Claude3VertexPlugin extends OpenAIVisionPlugin {
       let totalLength = 0;
       let totalUnits;
       messages.forEach((message, index) => {
-        const content = Array.isArray(message.content)
-          ? message.content.map((item) => JSON.stringify(sanitizeBase64(item))).join(", ")
-          : message.content;
+        let content;
+        if (Array.isArray(message.content)) {
+          // Only stringify objects, not strings (which may already be JSON strings)
+          content = message.content.map((item) => {
+            const sanitized = sanitizeBase64(item);
+            return typeof sanitized === 'string' ? sanitized : JSON.stringify(sanitized);
+          }).join(", ");
+        } else {
+          content = message.content;
+        }
         const { length, units } = this.getLength(content);
         const preview = this.shortenContent(content);
 
@@ -593,9 +600,15 @@ class Claude3VertexPlugin extends OpenAIVisionPlugin {
       logger.info(`[chat request contained ${totalLength} ${totalUnits}]`);
     } else {
       const message = messages[0];
-      const content = Array.isArray(message.content)
-        ? message.content.map((item) => JSON.stringify(item)).join(", ")
-        : message.content;
+      let content;
+      if (Array.isArray(message.content)) {
+        // Only stringify objects, not strings (which may already be JSON strings)
+        content = message.content.map((item) => {
+          return typeof item === 'string' ? item : JSON.stringify(item);
+        }).join(", ");
+      } else {
+        content = message.content;
+      }
       const { length, units } = this.getLength(content);
       logger.info(`[request sent containing ${length} ${units}]`);
       logger.verbose(`${this.shortenContent(content)}`);

package/server/plugins/claude4VertexPlugin.js

@@ -474,14 +474,19 @@ class Claude4VertexPlugin extends Claude3VertexPlugin {
       let totalLength = 0;
       let totalUnits;
       messages.forEach((message, index) => {
-        const content = Array.isArray(message.content)
-          ? message.content.map((item) => {
-              if (item.type === 'document') {
-                return `{type: document, source: ${JSON.stringify(sanitizeBase64(item.source))}}`;
-              }
-              return JSON.stringify(sanitizeBase64(item));
-            }).join(", ")
-          : message.content;
+        let content;
+        if (Array.isArray(message.content)) {
+          // Only stringify objects, not strings (which may already be JSON strings)
+          content = message.content.map((item) => {
+            if (item.type === 'document') {
+              return `{type: document, source: ${JSON.stringify(sanitizeBase64(item.source))}}`;
+            }
+            const sanitized = sanitizeBase64(item);
+            return typeof sanitized === 'string' ? sanitized : JSON.stringify(sanitized);
+          }).join(", ");
+        } else {
+          content = message.content;
+        }
         const { length, units } = this.getLength(content);
         const preview = this.shortenContent(content);
 
@@ -496,14 +501,19 @@ class Claude4VertexPlugin extends Claude3VertexPlugin {
       logger.info(`[chat request contained ${totalLength} ${totalUnits}]`);
     } else {
       const message = messages[0];
-      const content = Array.isArray(message.content)
-        ? message.content.map((item) => {
-            if (item.type === 'document') {
-              return `{type: document, source: ${JSON.stringify(sanitizeBase64(item.source))}}`;
-            }
-            return JSON.stringify(sanitizeBase64(item));
-          }).join(", ")
-        : message.content;
+      let content;
+      if (Array.isArray(message.content)) {
+        // Only stringify objects, not strings (which may already be JSON strings)
+        content = message.content.map((item) => {
+          if (item.type === 'document') {
+            return `{type: document, source: ${JSON.stringify(sanitizeBase64(item.source))}}`;
+          }
+          const sanitized = sanitizeBase64(item);
+          return typeof sanitized === 'string' ? sanitized : JSON.stringify(sanitized);
+        }).join(", ");
+      } else {
+        content = message.content;
+      }
       const { length, units } = this.getLength(content);
       logger.info(`[request sent containing ${length} ${units}]`);
       logger.verbose(`${this.shortenContent(content)}`);

package/server/plugins/grokResponsesPlugin.js

@@ -37,7 +37,18 @@ class GrokResponsesPlugin extends OpenAIVisionPlugin {
             let totalLength = 0;
             let totalUnits;
             messages.forEach((message, index) => {
-                const content = message.content === undefined ? JSON.stringify(sanitizeBase64(message)) : (Array.isArray(message.content) ? message.content.map(item => JSON.stringify(sanitizeBase64(item))).join(', ') : message.content);
+                let content;
+                if (message.content === undefined) {
+                    content = JSON.stringify(sanitizeBase64(message));
+                } else if (Array.isArray(message.content)) {
+                    // Only stringify objects, not strings (which may already be JSON strings)
+                    content = message.content.map(item => {
+                        const sanitized = sanitizeBase64(item);
+                        return typeof sanitized === 'string' ? sanitized : JSON.stringify(sanitized);
+                    }).join(', ');
+                } else {
+                    content = message.content;
+                }
                 const { length, units } = this.getLength(content);
                 const displayContent = this.shortenContent(content);
 
@@ -54,7 +65,16 @@ class GrokResponsesPlugin extends OpenAIVisionPlugin {
             logger.info(`[grok responses request contained ${totalLength} ${totalUnits}]`);
         } else if (messages && messages.length === 1) {
             const message = messages[0];
-            const content = Array.isArray(message.content) ? message.content.map(item => JSON.stringify(sanitizeBase64(item))).join(', ') : message.content;
+            let content;
+            if (Array.isArray(message.content)) {
+                // Only stringify objects, not strings (which may already be JSON strings)
+                content = message.content.map(item => {
+                    const sanitized = sanitizeBase64(item);
+                    return typeof sanitized === 'string' ? sanitized : JSON.stringify(sanitized);
+                }).join(', ');
+            } else {
+                content = message.content;
+            }
             const { length, units } = this.getLength(content);
             logger.info(`[grok responses request sent containing ${length} ${units}]`);
             logger.verbose(`${this.shortenContent(content)}`);

package/server/plugins/grokVisionPlugin.js

@@ -29,7 +29,18 @@ class GrokVisionPlugin extends OpenAIVisionPlugin {
             let totalUnits;
             messages.forEach((message, index) => {
                 //message.content string or array
-                const content = message.content === undefined ? JSON.stringify(sanitizeBase64(message)) : (Array.isArray(message.content) ? message.content.map(item => JSON.stringify(sanitizeBase64(item))).join(', ') : message.content);
+                let content;
+                if (message.content === undefined) {
+                    content = JSON.stringify(sanitizeBase64(message));
+                } else if (Array.isArray(message.content)) {
+                    // Only stringify objects, not strings (which may already be JSON strings)
+                    content = message.content.map(item => {
+                        const sanitized = sanitizeBase64(item);
+                        return typeof sanitized === 'string' ? sanitized : JSON.stringify(sanitized);
+                    }).join(', ');
+                } else {
+                    content = message.content;
+                }
                 const { length, units } = this.getLength(content);
                 const displayContent = this.shortenContent(content);
 
@@ -47,7 +58,16 @@ class GrokVisionPlugin extends OpenAIVisionPlugin {
             logger.info(`[grok request contained ${totalLength} ${totalUnits}]`);
         } else {
             const message = messages[0];
-            const content = Array.isArray(message.content) ? message.content.map(item => JSON.stringify(sanitizeBase64(item))).join(', ') : message.content;
+            let content;
+            if (Array.isArray(message.content)) {
+                // Only stringify objects, not strings (which may already be JSON strings)
+                content = message.content.map(item => {
+                    const sanitized = sanitizeBase64(item);
+                    return typeof sanitized === 'string' ? sanitized : JSON.stringify(sanitized);
+                }).join(', ');
+            } else {
+                content = message.content;
+            }
             const { length, units } = this.getLength(content);
             logger.info(`[grok request sent containing ${length} ${units}]`);
             logger.verbose(`${this.shortenContent(content)}`);

package/server/plugins/openAiVisionPlugin.js

@@ -159,7 +159,18 @@ class OpenAIVisionPlugin extends OpenAIChatPlugin {
             let totalUnits;
             messages.forEach((message, index) => {
                 //message.content string or array
-                const content = message.content === undefined ? JSON.stringify(sanitizeBase64(message)) : (Array.isArray(message.content) ? message.content.map(item => JSON.stringify(sanitizeBase64(item))).join(', ') : message.content);
+                let content;
+                if (message.content === undefined) {
+                    content = JSON.stringify(sanitizeBase64(message));
+                } else if (Array.isArray(message.content)) {
+                    // Only stringify objects, not strings (which may already be JSON strings)
+                    content = message.content.map(item => {
+                        const sanitized = sanitizeBase64(item);
+                        return typeof sanitized === 'string' ? sanitized : JSON.stringify(sanitized);
+                    }).join(', ');
+                } else {
+                    content = message.content;
+                }
                 const { length, units } = this.getLength(content);
                 const displayContent = this.shortenContent(content);
 
@@ -177,7 +188,16 @@ class OpenAIVisionPlugin extends OpenAIChatPlugin {
             logger.info(`[chat request contained ${totalLength} ${totalUnits}]`);
         } else {
             const message = messages[0];
-            const content = Array.isArray(message.content) ? message.content.map(item => JSON.stringify(sanitizeBase64(item))).join(', ') : message.content;
+            let content;
+            if (Array.isArray(message.content)) {
+                // Only stringify objects, not strings (which may already be JSON strings)
+                content = message.content.map(item => {
+                    const sanitized = sanitizeBase64(item);
+                    return typeof sanitized === 'string' ? sanitized : JSON.stringify(sanitized);
+                }).join(', ');
+            } else {
+                content = message.content;
+            }
             const { length, units } = this.getLength(content);
             logger.info(`[request sent containing ${length} ${units}]`);
             logger.verbose(`${this.shortenContent(content)}`);