@aj-archipelago/cortex 1.4.6 → 1.4.7

package/lib/pathwayTools.js

@@ -63,7 +63,13 @@ const callTool = async (toolName, args, toolDefinitions, pathwayResolver) => {
         throw new Error(`Tool ${toolName} not found in available tools`);
     }
 
-    logger.debug(`callTool: Starting execution of ${toolName}`);
+    // Create a sanitized copy of args for logging (exclude large objects like chatHistory)
+    const logArgs = { ...args };
+    if (logArgs.chatHistory) {
+        logArgs.chatHistory = `[${Array.isArray(logArgs.chatHistory) ? logArgs.chatHistory.length : 'N/A'} messages]`;
+    }
+    
+    logger.debug(`callTool: Starting execution of ${toolName} ${JSON.stringify(logArgs)}`);
 
     try {
         const pathwayName = toolDef.pathwayName;

package/lib/util.js

@@ -1,20 +1,8 @@
 import logger from "./logger.js";
-import stream from 'stream';
 import subvibe from '@aj-archipelago/subvibe';
-import os from 'os';
-import http from 'http';
-import https from 'https';
 import { URL } from 'url';
 import { v4 as uuidv4 } from 'uuid';
-import { promisify } from 'util';
-import { axios } from './requestExecutor.js';
-import { config } from '../config.js';
-import fs from 'fs';
-import path from 'path';
-import FormData from 'form-data';
 
-const pipeline = promisify(stream.pipeline);
-const MEDIA_API_URL = config.get('whisperMediaApiUrl');
 
 function getUniqueId(){
     return uuidv4();
@@ -107,70 +95,6 @@ function chatArgsHasImageUrl(args){
     return chatArgsHasType(args, 'image_url');
 }
 
-
-async function deleteTempPath(path) {
-    try {
-        if (!path) {
-            logger.warn('Temporary path is not defined.');
-            return;
-        }
-        if (!fs.existsSync(path)) {
-            logger.warn(`Temporary path ${path} does not exist.`);
-            return;
-        }
-        const stats = fs.statSync(path);
-        if (stats.isFile()) {
-            fs.unlinkSync(path);
-            logger.info(`Temporary file ${path} deleted successfully.`);
-        } else if (stats.isDirectory()) {
-            fs.rmSync(path, { recursive: true });
-            logger.info(`Temporary folder ${path} and its contents deleted successfully.`);
-        }
-    } catch (err) {
-        logger.error(`Error occurred while deleting the temporary path: ${err}`);
-    }
-}
-
-function generateUniqueFilename(extension) {
-    return `${uuidv4()}.${extension}`;
-}
-
-const downloadFile = async (fileUrl) => {
-    const urlObj = new URL(fileUrl);
-    const pathname = urlObj.pathname;
-    const fileExtension = pathname.substring(pathname.lastIndexOf('.') + 1);
-    const uniqueFilename = generateUniqueFilename(fileExtension);
-    const tempDir = os.tmpdir();
-    const localFilePath = `${tempDir}/${uniqueFilename}`;
-
-    // eslint-disable-next-line no-async-promise-executor
-    return new Promise(async (resolve, reject) => {
-        try {
-            const parsedUrl = new URL(fileUrl);
-            const protocol = parsedUrl.protocol === 'https:' ? https : http;
-
-            const response = await new Promise((resolve, reject) => {
-                protocol.get(parsedUrl, (res) => {
-                    if (res.statusCode === 200) {
-                        resolve(res);
-                    } else {
-                        reject(new Error(`HTTP request failed with status code ${res.statusCode}`));
-                    }
-                }).on('error', reject);
-            });
-
-            await pipeline(response, fs.createWriteStream(localFilePath));
-            logger.info(`Downloaded file to ${localFilePath}`);
-            resolve(localFilePath);
-        } catch (error) {
-            fs.unlink(localFilePath, () => {
-                reject(error);
-            });
-            //throw error;
-        }
-    });
-};
-
 // convert srt format to text
 function convertSrtToText(str) {
     return str
@@ -223,36 +147,6 @@ function alignSubtitles(subtitles, format, offsets) {
     }
 }
 
-
-async function getMediaChunks(file, requestId) {
-    try {
-        if (MEDIA_API_URL) {
-            //call helper api and get list of file uris
-            const res = await axios.get(MEDIA_API_URL, { params: { uri: file, requestId } });
-            return res.data;
-        } else {
-            logger.info(`No API_URL set, returning file as chunk`);
-            return [file];
-        }
-    } catch (err) {
-        logger.error(`Error getting media chunks list from api: ${err}`);
-        throw err;
-    }
-}
-
-async function markCompletedForCleanUp(requestId) {
-    try {
-        if (MEDIA_API_URL) {
-            //call helper api to mark processing as completed
-            const res = await axios.delete(MEDIA_API_URL, { params: { requestId } });
-            logger.info(`Marked request ${requestId} as completed: ${JSON.stringify(res.data)}`);
-            return res.data;
-        }
-    } catch (err) {
-        logger.error(`Error marking request ${requestId} as completed: ${err}`);
-    }
-}
-
 function removeOldImageAndFileContent(chatHistory) {
     if (!chatHistory || !Array.isArray(chatHistory) || chatHistory.length === 0) {
         return chatHistory;
@@ -387,204 +281,6 @@ function removeImageAndFileFromMessage(message) {
     return modifiedMessage;
 }
 
-// Helper function to extract file URLs from a content object
-function extractFileUrlsFromContent(contentObj) {
-    const urls = [];
-    if (contentObj.type === 'image_url' && contentObj.image_url?.url) {
-        urls.push(contentObj.image_url.url);
-    } else if (contentObj.type === 'file' && contentObj.file) {
-        urls.push(contentObj.file);
-    }
-    return urls;
-}
-
-function getAvailableFiles(chatHistory) {
-    const availableFiles = [];
-    
-    if (!chatHistory || !Array.isArray(chatHistory)) {
-        return availableFiles;
-    }
-    
-    for (const message of chatHistory) {
-        if (!message || !message.content) {
-            continue;
-        }
-        
-        // Handle array content
-        if (Array.isArray(message.content)) {
-            for (const content of message.content) {
-                try {
-                    const contentObj = typeof content === 'string' ? JSON.parse(content) : content;
-                    availableFiles.push(...extractFileUrlsFromContent(contentObj));
-                } catch (e) {
-                    // Not JSON or couldn't be parsed, continue
-                    continue;
-                }
-            }
-        }
-        // Handle string content
-        else if (typeof message.content === 'string') {
-            try {
-                const contentObj = JSON.parse(message.content);
-                availableFiles.push(...extractFileUrlsFromContent(contentObj));
-            } catch (e) {
-                // Not JSON or couldn't be parsed, continue
-                continue;
-            }
-        }
-        // Handle object content
-        else if (typeof message.content === 'object') {
-            availableFiles.push(...extractFileUrlsFromContent(message.content));
-        }
-    }
-    
-    return availableFiles;
-}
-
-// Helper function to upload base64 image data to cloud storage
-const uploadImageToCloud = async (base64Data, mimeType, pathwayResolver = null) => {
-    let tempFilePath = null;
-    let tempDir = null;
-    
-    try {
-        // Convert base64 to buffer
-        const imageBuffer = Buffer.from(base64Data, 'base64');
-        
-        // Determine file extension from mime type
-        const extension = mimeType.split('/')[1] || 'png';
-        const filename = `generated_image_${Date.now()}.${extension}`;
-        
-        // Create temporary file
-        tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'image-upload-'));
-        tempFilePath = path.join(tempDir, filename);
-        
-        // Write buffer to temp file
-        fs.writeFileSync(tempFilePath, imageBuffer);
-        
-        // Upload to file handler service
-        const fileHandlerUrl = MEDIA_API_URL;
-        if (!fileHandlerUrl) {
-            throw new Error('WHISPER_MEDIA_API_URL is not set');
-        }
-        const requestId = uuidv4();
-        
-        // Create form data for upload
-        const formData = new FormData();
-        formData.append('file', fs.createReadStream(tempFilePath), {
-            filename: filename,
-            contentType: mimeType
-        });
-        
-        // Append requestId parameter (preserving existing query parameters like subscription-key)
-        const separator = fileHandlerUrl.includes('?') ? '&' : '?';
-        const uploadUrl = `${fileHandlerUrl}${separator}requestId=${requestId}`;
-        
-        // Upload file
-        const uploadResponse = await axios.post(uploadUrl, formData, {
-            headers: {
-                ...formData.getHeaders()
-            },
-            timeout: 30000
-        });
-        
-        if (uploadResponse.data && uploadResponse.data.url) {
-            return uploadResponse.data.url;
-        } else {
-            throw new Error('No URL returned from file handler');
-        }
-        
-    } catch (error) {
-        const errorMessage = `Failed to upload image: ${error.message}`;
-        if (pathwayResolver && pathwayResolver.logError) {
-            pathwayResolver.logError(errorMessage);
-        } else {
-            logger.error(errorMessage);
-        }
-        throw error;
-    } finally {
-        // Clean up temp files
-        if (tempFilePath && fs.existsSync(tempFilePath)) {
-            try {
-                fs.unlinkSync(tempFilePath);
-            } catch (cleanupError) {
-                const warningMessage = `Failed to clean up temp file: ${cleanupError.message}`;
-                if (pathwayResolver && pathwayResolver.logWarning) {
-                    pathwayResolver.logWarning(warningMessage);
-                } else {
-                    logger.warn(warningMessage);
-                }
-            }
-        }
-        if (tempDir && fs.existsSync(tempDir)) {
-            try {
-                fs.rmdirSync(tempDir);
-            } catch (cleanupError) {
-                const warningMessage = `Failed to clean up temp directory: ${cleanupError.message}`;
-                if (pathwayResolver && pathwayResolver.logWarning) {
-                    pathwayResolver.logWarning(warningMessage);
-                } else {
-                    logger.warn(warningMessage);
-                }
-            }
-        }
-    }
-};
-
-/**
- * Convert file hashes to content format suitable for LLM processing
- * @param {Array<string>} fileHashes - Array of file hashes to resolve
- * @param {Object} config - Configuration object with file service endpoints
- * @returns {Promise<Array<string>>} Array of stringified file content objects
- */
-async function resolveFileHashesToContent(fileHashes, config) {
-    if (!fileHashes || fileHashes.length === 0) return [];
-
-    const fileContentPromises = fileHashes.map(async (hash) => {
-        try {
-            // Use the existing file handler (cortex-file-handler) to resolve file hashes
-            const fileHandlerUrl = config?.get?.('whisperMediaApiUrl');
-            
-            if (fileHandlerUrl && fileHandlerUrl !== 'null') {
-                // Make request to file handler to get file content by hash
-                const response = await axios.get(fileHandlerUrl, { 
-                    params: { hash: hash, checkHash: true } 
-                });
-                if (response.status === 200) {
-                    const fileData = response.data;
-                    const fileUrl = fileData.shortLivedUrl || fileData.url;
-                    const convertedUrl = fileData.converted?.url;
-                    const convertedGcsUrl = fileData.converted?.gcs;
-                    
-                    return JSON.stringify({
-                        type: "image_url",
-                        url: convertedUrl,
-                        image_url: { url: convertedUrl },
-                        gcs: convertedGcsUrl || fileData.gcs, // Add GCS URL for Gemini models
-                        originalFilename: fileData.filename,
-                        hash: hash
-                    });
-                }
-            }
-            
-            // Fallback: create a placeholder that indicates file resolution is needed
-            return JSON.stringify({
-                type: "file_hash",
-                hash: hash,
-                _cortex_needs_resolution: true
-            });
-        } catch (error) {
-            // Return error indicator
-            return JSON.stringify({
-                type: "file_error",
-                hash: hash,
-                error: error.message
-            });
-        }
-    });
-
-    return Promise.all(fileContentPromises);
-}
-
 export { 
     getUniqueId,
     getSearchResultId,
@@ -592,14 +288,7 @@ export {
     convertToSingleContentChatHistory,
     chatArgsHasImageUrl, 
     chatArgsHasType,
-    deleteTempPath,
-    downloadFile,
-    uploadImageToCloud,
     convertSrtToText,
     alignSubtitles,
-    getMediaChunks,
-    markCompletedForCleanUp,
-    removeOldImageAndFileContent,
-    getAvailableFiles,
-    resolveFileHashesToContent
-};
+    removeOldImageAndFileContent
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aj-archipelago/cortex",
-  "version": "1.4.6",
+  "version": "1.4.7",
   "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,7 +33,7 @@
   "type": "module",
   "homepage": "https://github.com/aj-archipelago/cortex#readme",
   "dependencies": {
-    "@aj-archipelago/merval": "^1.0.3",
+    "@aj-archipelago/merval": "^1.0.4",
     "@aj-archipelago/subvibe": "^1.0.12",
     "@apollo/server": "^4.7.3",
     "@apollo/server-plugin-response-cache": "^4.1.2",
@@ -67,7 +67,8 @@
     "mime-types": "^2.1.35",
     "uuid": "^9.0.0",
     "winston": "^3.11.0",
-    "ws": "^8.12.0"
+    "ws": "^8.12.0",
+    "xxhash-wasm": "^1.1.0"
   },
   "devDependencies": {
     "@faker-js/faker": "^8.4.1",

package/pathways/image_qwen.js

@@ -7,7 +7,7 @@ export default {
     negativePrompt: "",
     width: 1024,
     height: 1024,
-    aspectRatio: "16:9", // Options: "1:1", "16:9", "9:16", "4:3", "3:4", "match_input_image" (use "match_input_image" for qwen-image-edit-plus)
+    aspectRatio: "match_input_image", // Options: "1:1", "16:9", "9:16", "4:3", "3:4", "match_input_image" (use "match_input_image" for qwen-image-edit-plus)
     numberResults: 1,
     output_format: "webp",
     output_quality: 80, // Use 95 for qwen-image-edit-plus

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

@@ -99,19 +99,33 @@ export default {
             return savedContext.memoryContext || "";
         }
 
-        const validSections = ['memorySelf', 'memoryDirectives', 'memoryTopics', 'memoryUser', 'memoryContext', 'memoryVersion'];
+        const validSections = ['memorySelf', 'memoryDirectives', 'memoryTopics', 'memoryUser', 'memoryContext', 'memoryVersion', 'memoryFiles'];
+        // memoryFiles can only be accessed explicitly, not as part of memoryAll
+        const allSections = ['memorySelf', 'memoryDirectives', 'memoryTopics', 'memoryUser', 'memoryContext', 'memoryVersion'];
 
         if (section !== 'memoryAll') {
             if (validSections.includes(section)) {
                 const content = (getvWithDoubleDecryption && (await getvWithDoubleDecryption(`${contextId}-${section}`, contextKey))) || "";
+                // memoryFiles is JSON, skip processing but ensure it's a string
+                if (section === 'memoryFiles') {
+                    if (!content) {
+                        return "[]";
+                    }
+                    // If content is already an object (from getvWithDoubleDecryption parsing), stringify it
+                    if (typeof content === 'object') {
+                        return JSON.stringify(content);
+                    }
+                    // Otherwise it's already a string, return as-is
+                    return content;
+                }
                 return processMemoryContent(content, options);
             }
             return "";
         }
 
-        // otherwise, read all sections and return them as a JSON object
+        // otherwise, read all sections (excluding memoryFiles) and return them as a JSON object
         const memoryContents = {};
-        for (const section of validSections) {
+        for (const section of allSections) {
             if (section === 'memoryContext') continue;
 
             const content = (getvWithDoubleDecryption && (await getvWithDoubleDecryption(`${contextId}-${section}`, contextKey))) || "";

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

@@ -29,34 +29,50 @@ export default {
             return aiMemory;
         }
 
-        const validSections = ['memorySelf', 'memoryDirectives', 'memoryTopics', 'memoryUser', 'memoryVersion'];
+        const validSections = ['memorySelf', 'memoryDirectives', 'memoryTopics', 'memoryUser', 'memoryVersion', 'memoryFiles'];
+        // memoryFiles can only be accessed explicitly, not as part of memoryAll
+        const allSections = ['memorySelf', 'memoryDirectives', 'memoryTopics', 'memoryUser', 'memoryVersion'];
 
         // Handle single section save
         if (section !== 'memoryAll') {
             if (validSections.includes(section)) {
+                // memoryFiles should be JSON array, validate if provided
+                if (section === 'memoryFiles' && aiMemory && aiMemory.trim() !== '') {
+                    try {
+                        // Validate it's valid JSON (but keep as string for storage)
+                        JSON.parse(aiMemory);
+                    } catch (e) {
+                        // If not valid JSON, return error
+                        return JSON.stringify({ error: 'memoryFiles must be a valid JSON array' });
+                    }
+                }
                 await setvWithDoubleEncryption(`${contextId}-${section}`, aiMemory, contextKey);
             }
             return aiMemory;
         }
 
-        // if the aiMemory is an empty string, set all sections to empty strings
+        // if the aiMemory is an empty string, set all sections (excluding memoryFiles) to empty strings
         if (aiMemory.trim() === "") {
-            for (const section of validSections) {
+            for (const section of allSections) {
                 await setvWithDoubleEncryption(`${contextId}-${section}`, "", contextKey);
             }
             return "";
         }
         
-        // Handle multi-section save
+        // Handle multi-section save (excluding memoryFiles)
         try {
             const memoryObject = JSON.parse(aiMemory);
-            for (const section of validSections) {
+            for (const section of allSections) {
                 if (section in memoryObject) {
                     await setvWithDoubleEncryption(`${contextId}-${section}`, memoryObject[section], contextKey);
                 }
             }
+            // Explicitly ignore memoryFiles if present in the object
+            if ('memoryFiles' in memoryObject) {
+                // Silently ignore - memoryFiles can only be saved explicitly
+            }
         } catch {
-            for (const section of validSections) {
+            for (const section of allSections) {
                 await setvWithDoubleEncryption(`${contextId}-${section}`, "", contextKey);
             }
             await setvWithDoubleEncryption(`${contextId}-memoryUser`, aiMemory, contextKey);

package/pathways/system/entity/sys_entity_agent.js

@@ -5,7 +5,8 @@ const MAX_TOOL_CALLS = 50;
 import { callPathway, callTool, say } from '../../../lib/pathwayTools.js';
 import logger from '../../../lib/logger.js';
 import { config } from '../../../config.js';
-import { chatArgsHasImageUrl, removeOldImageAndFileContent, getAvailableFiles } from '../../../lib/util.js';
+import { chatArgsHasImageUrl, removeOldImageAndFileContent } from '../../../lib/util.js';
+import { getAvailableFiles } from '../../../lib/fileUtils.js';
 import { Prompt } from '../../../server/prompt.js';
 import { getToolsForEntity, loadEntityConfig } from './tools/shared/sys_entity_tools.js';
 import CortexResponse from '../../../lib/cortexResponse.js';
@@ -329,7 +330,11 @@ export default {
                 memoryLookupRequiredPromise = Promise.race([
                     callPathway('sys_memory_lookup_required', { ...args, chatHistory: chatHistoryLastTurn, stream: false }),
                     timeoutPromise
-                ]);
+                ]).catch(error => {
+                    // Handle timeout or other errors gracefully - return null so the await doesn't throw
+                    logger.warn(`Memory lookup promise rejected: ${error.message}`);
+                    return null;
+                });
             }
         }
         
@@ -388,7 +393,8 @@ export default {
             args.chatHistory = args.chatHistory.slice(-20);
         }
 
-        const availableFiles = getAvailableFiles(args.chatHistory);
+        // Get available files from collection (async, syncs files from chat history)
+        const availableFiles = await getAvailableFiles(args.chatHistory, args.contextId, args.contextKey);
 
         // remove old image and file content
         const visionContentPresent = chatArgsHasImageUrl(args);
@@ -407,7 +413,18 @@ export default {
 
         try {
             if (memoryLookupRequiredPromise) {
-                memoryLookupRequired = JSON.parse(await memoryLookupRequiredPromise)?.memoryRequired;
+                const result = await memoryLookupRequiredPromise;
+                // If result is null (timeout) or empty, default to false
+                if (result && typeof result === 'string') {
+                    try {
+                        memoryLookupRequired = JSON.parse(result)?.memoryRequired || false;
+                    } catch (parseError) {
+                        logger.warn(`Failed to parse memory lookup result: ${parseError.message}`);
+                        memoryLookupRequired = false;
+                    }
+                } else {
+                    memoryLookupRequired = false;
+                }
             } else {
                 memoryLookupRequired = false;
             }