@aj-archipelago/cortex 1.3.5 → 1.3.7

package/server/pathwayResolver.js

@@ -223,21 +223,42 @@ class PathwayResolver {
         this.savedContextId = contextId ? contextId : uuidv4();
         
         const loadMemory = async () => {
-            // Load initial values
-            this.savedContext = (getv && await getv(contextId)) || {};
-            this.memorySelf = (getv && await getv(`${contextId}-memorySelf`)) || "";
-            this.memoryDirectives = (getv && await getv(`${contextId}-memoryDirectives`)) || "";
-            this.memoryTopics = (getv && await getv(`${contextId}-memoryTopics`)) || "";
-            this.memoryUser = (getv && await getv(`${contextId}-memoryUser`)) || "";
-
-            // Store initial state for comparison
-            this.initialState = {
-                savedContext: this.savedContext,
-                memorySelf: this.memorySelf,
-                memoryDirectives: this.memoryDirectives,
-                memoryTopics: this.memoryTopics,
-                memoryUser: this.memoryUser
-            };
+            try {
+                // Load saved context and core memory if it exists
+                const [savedContext, memorySelf, memoryDirectives, memoryTopics, memoryUser, memoryContext] = await Promise.all([
+                    (getv && await getv(this.savedContextId)) || {},
+                    callPathway('sys_read_memory', { contextId: this.savedContextId, section: 'memorySelf', priority: 1}),
+                    callPathway('sys_read_memory', { contextId: this.savedContextId, section: 'memoryDirectives', priority: 1 }),
+                    callPathway('sys_read_memory', { contextId: this.savedContextId, section: 'memoryTopics', priority: 0, numResults: 10 }),
+                    callPathway('sys_read_memory', { contextId: this.savedContextId, section: 'memoryUser', priority: 1 }),
+                    callPathway('sys_read_memory', { contextId: this.savedContextId, section: 'memoryContext', priority: 0 }),
+                ]).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,
+                };
+            } catch (error) {
+                this.logError(`Error in loadMemory: ${error.message}`);
+                // Set default values in case of error
+                this.savedContext = {};
+                this.memorySelf = '';
+                this.memoryDirectives = '';
+                this.memoryTopics = '';
+                this.memoryUser = '';
+                this.memoryContext = '';
+                this.initialState = { savedContext: {} };
+            }
         };
 
         const saveChangedMemory = async () => {
@@ -245,27 +266,11 @@ class PathwayResolver {
             
             const currentState = {
                 savedContext: this.savedContext,
-                memorySelf: this.memorySelf,
-                memoryDirectives: this.memoryDirectives,
-                memoryTopics: this.memoryTopics,
-                memoryUser: this.memoryUser
             };
 
             if (currentState.savedContext !== this.initialState.savedContext) {
                 setv && await setv(this.savedContextId, this.savedContext);
             }
-            if (currentState.memorySelf !== this.initialState.memorySelf) {
-                setv && await setv(`${this.savedContextId}-memorySelf`, this.memorySelf);
-            }
-            if (currentState.memoryDirectives !== this.initialState.memoryDirectives) {
-                setv && await setv(`${this.savedContextId}-memoryDirectives`, this.memoryDirectives);
-            }
-            if (currentState.memoryTopics !== this.initialState.memoryTopics) {
-                setv && await setv(`${this.savedContextId}-memoryTopics`, this.memoryTopics);
-            }
-            if (currentState.memoryUser !== this.initialState.memoryUser) {
-                setv && await setv(`${this.savedContextId}-memoryUser`, this.memoryUser);
-            }
         };
 
         const MAX_RETRIES = 3;
@@ -344,6 +349,11 @@ class PathwayResolver {
 
     // Calculate the maximum token length for a chunk
     getChunkMaxTokenLength() {
+        // Skip expensive calculations if not using input chunking
+        if (!this.useInputChunking) {
+            return this.modelExecutor.plugin.getModelMaxTokenLength();
+        }
+
         // find the longest prompt
         const maxPromptTokenLength = Math.max(...this.prompts.map((promptData) => this.modelExecutor.plugin.getCompiledPrompt('', this.args, promptData).tokenLength));
         

package/server/plugins/azureVideoTranslatePlugin.js

@@ -7,13 +7,13 @@ import { config } from "../../config.js";
 
 function isValidJSON(str) {
     try {
-      JSON.parse(str);
-      return true;
+        JSON.parse(str);
+        return true;
     } catch (e) {
-      return false;
+        return false;
     }
 }
-  
+
 class AzureVideoTranslatePlugin extends ModelPlugin {
     constructor(pathway, model) {
         super(pathway, model);
@@ -21,8 +21,6 @@ class AzureVideoTranslatePlugin extends ModelPlugin {
         this.eventSource = null;
         this.jsonBuffer = '';
         this.jsonDepth = 0;
-        this.currentStep = 0;
-        this.totalNumOfSteps = 30;
     }
 
     getRequestParameters(_, parameters, __) {
@@ -77,11 +75,23 @@ class AzureVideoTranslatePlugin extends ModelPlugin {
         this.jsonDepth += (data.match(/{/g) || []).length - (data.match(/}/g) || []).length;
 
         if (this.jsonDepth === 0 && this.jsonBuffer.trim()) {
-            console.log(this.jsonBuffer);
+            logger.debug(this.jsonBuffer);
             if (this.jsonBuffer.includes('Failed to run with exception')) {
                 this.cleanup();
                 throw new Error(this.jsonBuffer);
             }
+
+            if (isValidJSON(this.jsonBuffer)) {
+                const parsedData = JSON.parse(this.jsonBuffer);
+                if (parsedData.progress !== undefined) {
+                    publishRequestProgress({
+                        requestId: this.requestId,
+                        progress: parsedData.progress,
+                        info: this.jsonBuffer
+                    });
+                }
+            }
+
             onData(this.jsonBuffer);
             this.jsonBuffer = '';
             this.jsonDepth = 0;
@@ -106,21 +116,23 @@ class AzureVideoTranslatePlugin extends ModelPlugin {
 
             return new Promise((resolve, reject) => {
                 let finalJson = '';
-                this.handleStream(response.data, 
-                    (data) => { 
-                        this.currentStep++;
+                this.handleStream(response.data,
+                    (data) => {
                         publishRequestProgress({
                             requestId: this.requestId,
-                            progress: this.currentStep / this.totalNumOfSteps,
-                            // data: this.jsonBuffer,
                             info: data
                         });
-                        if (isValidJSON(data)) {
-                            finalJson = data;
-                        }
+                        logger.debug('Data:', data);
+                        // Extract JSON content if message contains targetLocales
+                        const jsonMatch = data.match(/{[\s\S]*"targetLocales"[\s\S]*}/);
+                        if (jsonMatch) {
+                            const extractedJson = jsonMatch[0];
+                            if (isValidJSON(extractedJson)) {
+                                finalJson = extractedJson;
+                            }
+                        } 
                     },
                     () => {
-                        // console.log('Full data:', fullData);
                         resolve(finalJson)
                     },
                     (error) => reject(error)

package/server/plugins/claude3VertexPlugin.js

@@ -309,15 +309,6 @@ class Claude3VertexPlugin extends OpenAIVisionPlugin {
     return requestProgress;
   }
 
-  shortenContent(content, maxWords = 40) {
-    const words = content.split(" ");
-    if (words.length <= maxWords || logger.level === 'debug') {
-      return content;
-    }
-    return words.slice(0, maxWords / 2).join(" ") +
-      " ... " +
-      words.slice(-maxWords / 2).join(" ");
-  }
 }
 
 export default Claude3VertexPlugin;

package/server/plugins/gemini15ChatPlugin.js

@@ -179,24 +179,37 @@ class Gemini15ChatPlugin extends ModelPlugin {
                 const messageContent = message.parts.reduce((acc, part) => {
                     if (part.text) {
                         return acc + part.text;
+                    } else if (part.inlineData) {
+                        return acc + '* base64 data truncated for log *';
+                    } else if (part.fileData) {
+                        return acc + part.fileData.fileUri;
                     }
                     return acc;
                 } , '');
-                const words = messageContent.split(" ");
                 const { length, units } = this.getLength(messageContent);
-                const preview = words.length < 41 ? messageContent : words.slice(0, 20).join(" ") + " ... " + words.slice(-20).join(" ");
+                const preview = this.shortenContent(messageContent);
     
                 logger.verbose(`message ${index + 1}: role: ${message.role}, ${units}: ${length}, content: "${preview}"`);
             });
         } else if (messages && messages.length === 1) {
-            logger.verbose(`${messages[0].parts[0].text}`);
+            const messageContent = messages[0].parts.reduce((acc, part) => {
+                if (part.text) {
+                    return acc + part.text;
+                } else if (part.inlineData) {
+                    return acc + '* base64 data truncated for log *';
+                } else if (part.fileData) {
+                    return acc + part.fileData.fileUri;
+                }
+                return acc;
+            } , '');
+            logger.verbose(`${this.shortenContent(messageContent)}`);
         }
 
         // check if responseData is an array or string
         if (typeof responseData === 'string') {
             const { length, units } = this.getLength(responseData);
             logger.info(`[response received containing ${length} ${units}]`);
-            logger.verbose(`${responseData}`);
+            logger.verbose(`${this.shortenContent(responseData)}`);
         } else if (Array.isArray(responseData)) {
             const { mergedResult, safetyRatings } = mergeResults(responseData);
             if (safetyRatings?.length) {
@@ -205,7 +218,7 @@ class Gemini15ChatPlugin extends ModelPlugin {
             }
             const { length, units } = this.getLength(mergedResult);
             logger.info(`[response received containing ${length} ${units}]`);
-            logger.verbose(`${mergedResult}`);
+            logger.verbose(`${this.shortenContent(mergedResult)}`);
         } else {
             logger.info(`[response received as an SSE stream]`);
         }

package/server/plugins/modelPlugin.js

@@ -36,11 +36,19 @@ class ModelPlugin {
         this.requestCount = 0;
     }
 
+    safeGetEncodedLength(data) {
+        if (data && data.length > 100000) {
+            return data.length * 3 / 16;
+        } else {
+            return encode(data).length;
+        }
+    }
+
     truncateMessagesToTargetLength(messages, targetTokenLength) {
         // Calculate the token length of each message
         const tokenLengths = messages.map((message) => ({
             message,
-            tokenLength: encode(this.messagesToChatML([message], false)).length,
+            tokenLength: this.safeGetEncodedLength(this.messagesToChatML([message], false)),
         }));
     
         // Calculate the total token length of all messages
@@ -89,7 +97,7 @@ class ModelPlugin {
 
                     tokenLengths[index] = {
                         message: truncatedMessage,
-                        tokenLength: encode(this.messagesToChatML([ truncatedMessage ], false)).length
+                        tokenLength: this.safeGetEncodedLength(this.messagesToChatML([ truncatedMessage ], false))
                     }
 
                     // calculate the length again to keep us honest
@@ -141,9 +149,9 @@ class ModelPlugin {
         const modelPromptMessagesML = this.messagesToChatML(modelPromptMessages);
 
         if (modelPromptMessagesML) {
-            return { modelPromptMessages, tokenLength: encode(modelPromptMessagesML).length, modelPrompt };
+            return { modelPromptMessages, tokenLength: this.safeGetEncodedLength(modelPromptMessagesML), modelPrompt };
         } else {
-            return { modelPromptText, tokenLength: encode(modelPromptText).length, modelPrompt };
+            return { modelPromptText, tokenLength: this.safeGetEncodedLength(modelPromptText), modelPrompt };
         }
     }
 
@@ -260,19 +268,32 @@ class ModelPlugin {
         return {length, units};
     }
 
+    shortenContent(content, maxWords = 40) {
+        if (!content || typeof content !== 'string') {
+            return content;
+        }
+        const words = content.split(" ");
+        if (words.length <= maxWords || logger.level === 'debug') {
+            return content;
+        }
+        return words.slice(0, maxWords / 2).join(" ") +
+            " ... " +
+            words.slice(-maxWords / 2).join(" ");
+    }
+
     logRequestData(data, responseData, prompt) {
         const modelInput = data.prompt || (data.messages && data.messages[0].content) || (data.length > 0 && data[0].Text) || null;
     
         if (modelInput) {
             const { length, units } = this.getLength(modelInput);
             logger.info(`[request sent containing ${length} ${units}]`);
-            logger.verbose(`${modelInput}`);
+            logger.verbose(`${this.shortenContent(modelInput)}`);
         }
     
         const responseText = JSON.stringify(responseData);
         const { length, units } = this.getLength(responseText);
         logger.info(`[response received containing ${length} ${units}]`);
-        logger.verbose(`${responseText}`);
+        logger.verbose(`${this.shortenContent(responseText)}`);
     
         prompt && prompt.debugInfo && (prompt.debugInfo += `\n${JSON.stringify(data)}`);
     }

package/server/plugins/openAiChatPlugin.js

@@ -61,7 +61,7 @@ class OpenAIChatPlugin extends ModelPlugin {
         }
     
         // Check if the token length exceeds the model's max token length
-        if (tokenLength > modelTargetTokenLength) {
+        if (tokenLength > modelTargetTokenLength && this.promptParameters?.manageTokenLength) {
             // Remove older messages until the token length is within the model's limit
             requestMessages = this.truncateMessagesToTargetLength(requestMessages, modelTargetTokenLength);
         }
@@ -112,11 +112,11 @@ class OpenAIChatPlugin extends ModelPlugin {
             let totalUnits;
             messages.forEach((message, index) => {
                 //message.content string or array
-                const content = message.content === undefined ? JSON.stringify(message) : (Array.isArray(message.content) ? message.content.map(item => JSON.stringify(item)).join(', ') : message.content);
-                const words = content.split(" ");
+                const content = message.content === undefined ? JSON.stringify(message) : (Array.isArray(message.content) ? message.content.map(item => {
+                    return JSON.stringify(item);
+                }).join(', ') : message.content);
                 const { length, units } = this.getLength(content);
-                
-                const displayContent = logger.level === 'debug' ? content : (words.length < 41 ? content : words.slice(0, 20).join(" ") + " ... " + words.slice(-20).join(" "));
+                const displayContent = this.shortenContent(content);
 
                 logger.verbose(`message ${index + 1}: role: ${message.role}, ${units}: ${length}, content: "${displayContent}"`);
                 totalLength += length;
@@ -125,10 +125,12 @@ class OpenAIChatPlugin extends ModelPlugin {
             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;
+            const content = Array.isArray(message.content) ? message.content.map(item => {
+                return JSON.stringify(item);
+            }).join(', ') : message.content;
             const { length, units } = this.getLength(content);
             logger.info(`[request sent containing ${length} ${units}]`);
-            logger.verbose(`${content}`);
+            logger.verbose(`${this.shortenContent(content)}`);
         }
     
         if (stream) {
@@ -137,7 +139,7 @@ class OpenAIChatPlugin extends ModelPlugin {
             const responseText = this.parseResponse(responseData);
             const { length, units } = this.getLength(responseText);
             logger.info(`[response received containing ${length} ${units}]`);
-            logger.verbose(`${responseText}`);
+            logger.verbose(`${this.shortenContent(responseText)}`);
         }
 
         prompt && prompt.debugInfo && (prompt.debugInfo += `\n${JSON.stringify(data)}`);

package/server/plugins/openAiVisionPlugin.js

@@ -1,4 +1,5 @@
 import OpenAIChatPlugin from './openAiChatPlugin.js';
+import logger from '../../lib/logger.js';
 
 function safeJsonParse(content) {
     try {
@@ -44,6 +45,61 @@ class OpenAIVisionPlugin extends OpenAIChatPlugin {
         });
     }
 
+    // Override the logging function to display the messages and responses
+    logRequestData(data, responseData, prompt) {
+        const { stream, messages } = data;
+        if (messages && messages.length > 1) {
+            logger.info(`[chat request sent containing ${messages.length} messages]`);
+            let totalLength = 0;
+            let totalUnits;
+            messages.forEach((message, index) => {
+                //message.content string or array
+                const content = message.content === undefined ? JSON.stringify(message) : (Array.isArray(message.content) ? message.content.map(item => {
+                    if (item.type === 'image_url' && item.image_url?.url?.startsWith('data:')) {
+                        return JSON.stringify({
+                            type: 'image_url',
+                            image_url: { url: '* base64 data truncated for log *' }
+                        });
+                    }
+                    return JSON.stringify(item);
+                }).join(', ') : message.content);
+                const { length, units } = this.getLength(content);
+                const displayContent = this.shortenContent(content);
+
+                logger.verbose(`message ${index + 1}: role: ${message.role}, ${units}: ${length}, content: "${displayContent}"`);
+                totalLength += length;
+                totalUnits = units;
+            });
+            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 === 'image_url' && item.image_url?.url?.startsWith('data:')) {
+                    return JSON.stringify({
+                        type: 'image_url',
+                        image_url: { url: '* base64 data truncated for log *' }
+                    });
+                }
+                return JSON.stringify(item);
+            }).join(', ') : message.content;
+            const { length, units } = this.getLength(content);
+            logger.info(`[request sent containing ${length} ${units}]`);
+            logger.verbose(`${this.shortenContent(content)}`);
+        }
+    
+        if (stream) {
+            logger.info(`[response received as an SSE stream]`);
+        } else {
+            const responseText = this.parseResponse(responseData);
+            const { length, units } = this.getLength(responseText);
+            logger.info(`[response received containing ${length} ${units}]`);
+            logger.verbose(`${this.shortenContent(responseText)}`);
+        }
+
+        prompt && prompt.debugInfo && (prompt.debugInfo += `\n${JSON.stringify(data)}`);
+    }
+
+
     getRequestParameters(text, parameters, prompt) {
         const requestParameters = super.getRequestParameters(text, parameters, prompt);
 

package/tests/memoryfunction.test.js

@@ -1,5 +1,5 @@
 import test from 'ava';
-import { enforceTokenLimit } from '../pathways/system/entity/memory/sys_memory_update.js';
+import { enforceTokenLimit, modifyText } from '../pathways/system/entity/memory/sys_memory_update.js';
 
 test('enforceTokenLimit preserves priority order correctly', t => {
     const input = `
@@ -61,4 +61,76 @@ Item without priority
     
     t.true(result.includes('[P3] Item without priority'));
     t.true(result.includes('[P1] Item with priority'));
+});
+
+test('modifyText handles delete operations with escaped characters', t => {
+    const input = '[P2] Pizza Connection: Has special appreciation for Pisanello\'s';
+    const modifications = [{
+        type: 'delete',
+        pattern: '\\[P2\\] Pizza Connection: Has special appreciation for Pisanello\'s'
+    }];
+    
+    const result = modifyText(input, modifications);
+    t.false(result.includes('Pizza Connection'));
+});
+
+test('modifyText handles delete with partial priority match', t => {
+    const input = '[P3] Test memory item';
+    const modifications = [{
+        type: 'delete',
+        pattern: 'Test memory item'
+    }];
+    
+    const result = modifyText(input, modifications);
+    t.false(result.includes('Test memory item'));
+});
+
+test('modifyText handles multiple modifications in sequence', t => {
+    const input = '[P2] Keep this line\n[P3] Delete this line\n[P1] Also keep this';
+    const modifications = [
+        { type: 'delete', pattern: 'Delete this line' },
+        { type: 'add', newtext: 'New line added', priority: '2' }
+    ];
+    
+    const result = modifyText(input, modifications);
+    t.true(result.includes('Keep this line'));
+    t.true(result.includes('Also keep this'));
+    t.true(result.includes('[P2] New line added'));
+    t.false(result.includes('Delete this line'));
+});
+
+test('modifyText handles delete with whitespace variations', t => {
+    const input = '  [P2]  Item with spaces  \n[P3]Item without spaces';
+    const modifications = [
+        { type: 'delete', pattern: 'Item with spaces' },
+        { type: 'delete', pattern: 'Item without spaces' }
+    ];
+    
+    const result = modifyText(input, modifications);
+    t.false(result.includes('Item with spaces'));
+    t.false(result.includes('Item without spaces'));
+});
+
+test('modifyText preserves existing priority when adding with priority in text', t => {
+    const input = '';
+    const modifications = [{
+        type: 'add',
+        newtext: '[P1] High priority item',
+        priority: '3' // This should be ignored since priority is in text
+    }];
+    
+    const result = modifyText(input, modifications);
+    t.true(result.includes('[P1] High priority item'));
+    t.false(result.includes('[P3] [P1] High priority item'));
+});
+
+test('modifyText handles delete with regex special characters', t => {
+    const input = '[P2] Special (chars) [test] {here} *star*';
+    const modifications = [{
+        type: 'delete',
+        pattern: 'Special \\(chars\\) \\[test\\] \\{here\\} \\*star\\*'
+    }];
+    
+    const result = modifyText(input, modifications);
+    t.false(result.includes('Special (chars)'));
 });