@aj-archipelago/cortex 1.4.21 → 1.4.23

package/lib/fileUtils.js

@@ -768,6 +768,47 @@ async function loadFileCollection(contextId, contextKey = null, useCache = true,
     return filterAndFormatFileCollection(rawFiles, chatId);
 }
 
+/**
+ * Load ALL files from a context's file collection, bypassing inCollection filtering.
+ * Used when merging alt contexts where we want all files regardless of chat scope.
+ * @param {string} contextId - Context ID
+ * @param {string|null} contextKey - Optional encryption key
+ * @returns {Promise<Array>} All files in the collection
+ */
+async function loadFileCollectionAll(contextId, contextKey = null) {
+    if (!contextId) {
+        return [];
+    }
+
+    try {
+        const redisClient = await getRedisClient();
+        
+        if (redisClient) {
+            const contextMapKey = `FileStoreMap:ctx:${contextId}`;
+            const allFiles = await redisClient.hgetall(contextMapKey);
+            
+            // Parse raw file data
+            const rawFiles = parseRawFileData(allFiles, contextKey);
+            
+            // Return all files without inCollection filtering, just remove the internal metadata
+            const formatted = rawFiles.map(({ inCollection, ...file }) => file);
+            
+            // Sort by lastAccessed (most recent first)
+            formatted.sort((a, b) => {
+                const aDate = new Date(a.lastAccessed || a.addedDate || 0);
+                const bDate = new Date(b.lastAccessed || b.addedDate || 0);
+                return bDate - aDate;
+            });
+            
+            return formatted;
+        }
+    } catch (e) {
+        // Collection doesn't exist yet or error reading
+    }
+    
+    return [];
+}
+
 /**
  * Normalize inCollection value to array format
  * @param {boolean|Array<string>|undefined} inCollection - inCollection value to normalize
@@ -819,8 +860,12 @@ async function updateFileMetadata(contextId, hash, metadata, contextKey = null)
         }
         
         const contextMapKey = `FileStoreMap:ctx:${contextId}`;
-        // Get existing file data from CFH (if any)
+        // Get existing file data - must exist to update
         const existingDataStr = await redisClient.hget(contextMapKey, hash);
+        if (!existingDataStr) {
+            // File doesn't exist in this context - don't create new entries
+            return false;
+        }
         const existingData = readFileDataFromRedis(existingDataStr, contextKey) || {};
         
         // Merge CFH data with Cortex metadata
@@ -1238,135 +1283,6 @@ function getActualContentMimeType(file) {
     return determineMimeTypeFromUrl(file.url, file.gcs, null);
 }
 
-/**
- * Sync files from chat history to file collection
- * @param {Array} chatHistory - Chat history to scan
- * @param {string} contextId - Context ID for the file collection
- * @param {string} contextKey - Optional context key for encryption
- * @returns {Promise<Array>} Array of file metadata objects
- */
-async function syncFilesToCollection(chatHistory, contextId, contextKey = null) {
-    if (!chatHistory || !Array.isArray(chatHistory) || !contextId) {
-        return [];
-    }
-
-    // Extract all files from chat history
-    const extractedFiles = extractFilesFromChatHistory(chatHistory);
-
-    if (extractedFiles.length === 0) {
-        // No new files to add, return existing collection
-        return await loadFileCollection(contextId, contextKey, true);
-    }
-
-    // Sync files - check individually and update only what's needed (atomic operations)
-    try {
-        const redisClient = await getRedisClient();
-        if (!redisClient) {
-            // No Redis, return existing collection
-            return await loadFileCollection(contextId, contextKey, true);
-        }
-        
-        const contextMapKey = `FileStoreMap:ctx:${contextId}`;
-        const existingFiles = await redisClient.hgetall(contextMapKey);
-        const existingByUrl = new Map();
-        const existingByGcs = new Map();
-        const existingByHash = new Map();
-        
-        // Build lookup maps from existing files
-        for (const [hash, dataStr] of Object.entries(existingFiles)) {
-            try {
-                const data = JSON.parse(dataStr);
-                if (data.url) existingByUrl.set(data.url, hash);
-                if (data.gcs) existingByGcs.set(data.gcs, hash);
-                if (hash) existingByHash.set(hash, hash);
-            } catch (e) {
-                // Skip invalid entries
-            }
-        }
-        
-        // Add/update files individually (atomic operations)
-        for (const file of extractedFiles) {
-            const existsByUrl = file.url && existingByUrl.has(file.url);
-            const existsByGcs = file.gcs && existingByGcs.has(file.gcs);
-            const existsByHash = file.hash && existingByHash.has(file.hash);
-            
-            if (!existsByUrl && !existsByGcs && !existsByHash && file.hash) {
-                // File not found in context-scoped map - check if CFH has it (context-scoped or unscoped)
-                // This handles the case where file was uploaded but not yet in this context's collection
-                const existingDataStr = await redisClient.hget(contextMapKey, file.hash);
-                let existingData = readFileDataFromRedis(existingDataStr, contextKey);
-                
-                // Also check unscoped map (CFH might have written it there)
-                if (!existingData) {
-                    const unscopedDataStr = await redisClient.hget("FileStoreMap", file.hash);
-                    existingData = readFileDataFromRedis(unscopedDataStr, contextKey);
-                }
-                
-                if (existingData) {
-                    // CFH already has this file - merge CFH data with Cortex metadata
-                    // Only set Cortex-managed fields (tags, notes, id, dates), preserve all CFH data
-                    // Ensure mimeType is set (CFH doesn't store it, so we need to determine it)
-                    // IMPORTANT: Determine MIME type from URL (actual content), not displayFilename
-                    // displayFilename may have original extension (e.g., .docx) while URL points to converted content (e.g., .md)
-                    const mimeType = existingData.mimeType || determineMimeTypeFromUrl(existingData.url, existingData.gcs, null);
-                    
-                    const fileData = {
-                        ...existingData, // Preserve all CFH data (url, gcs, filename, displayFilename, permanent, etc.)
-                        mimeType: mimeType, // Ensure mimeType is set
-                        id: existingData.id || `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`,
-                        tags: existingData.tags || [],
-                        notes: existingData.notes || '',
-                        addedDate: existingData.addedDate || existingData.timestamp || new Date().toISOString(),
-                        lastAccessed: new Date().toISOString(),
-                        inCollection: ['*'] // Mark as global chat file (available to all chats)
-                    };
-                    
-                    // Write to Redis - encryption happens in helper
-                    await writeFileDataToRedis(redisClient, contextMapKey, file.hash, fileData, contextKey);
-                } else {
-                    // File doesn't exist in CFH - create minimal entry (file referenced in chat but not uploaded)
-                    const mimeType = determineMimeTypeFromUrl(file.url, file.gcs, null);
-                    
-                    const fileData = {
-                        url: file.url,
-                        gcs: file.gcs || null,
-                        mimeType: mimeType,
-                        id: `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`,
-                        tags: [],
-                        notes: '',
-                        hash: file.hash,
-                        permanent: false,
-                        addedDate: new Date().toISOString(),
-                        lastAccessed: new Date().toISOString(),
-                        inCollection: ['*'] // Mark as global chat file (available to all chats)
-                    };
-                    
-                    // Write to Redis - encryption happens in helper
-                    await writeFileDataToRedis(redisClient, contextMapKey, file.hash, fileData, contextKey);
-                }
-            } else if (file.hash) {
-                // File exists - update lastAccessed directly
-                await updateFileMetadata(contextId, file.hash, {
-                    lastAccessed: new Date().toISOString()
-                }, contextKey);
-            }
-        }
-        
-        // Invalidate cache
-        const cacheKey = getCollectionCacheKey(contextId, contextKey);
-        fileCollectionCache.delete(cacheKey);
-    } catch (e) {
-        // Fallback: log error and return existing collection
-        const logger = (await import('./logger.js')).default;
-        logger.warn(`Failed to sync files individually: ${e.message}`);
-        // Return existing collection on error
-        return await loadFileCollection(contextId, contextKey, true);
-    }
-
-    // Return updated collection
-    return await loadFileCollection(contextId, contextKey, false);
-}
-
 /**
  * Get available files from file collection and format for template
  * @param {string} contextId - Context ID for the file collection
@@ -1430,69 +1346,160 @@ function formatFilesForTemplate(collection) {
 }
 
 /**
- * Get available files - now async and works with file collection
- * @param {Array} chatHistory - Chat history to scan
- * @param {string} contextId - Context ID for the file collection
- * @param {string} contextKey - Optional context key for encryption
- * @returns {Promise<string>} Formatted string of available files
+ * Extract default context from agentContext array (for writes/updates)
+ * @param {Array} agentContext - Array of context objects { contextId, contextKey, default }
+ * @returns {Object|null} Default context object or null if not found
  */
-async function getAvailableFiles(chatHistory, contextId, contextKey = null) {
-    if (!contextId) {
-        // Fallback to old behavior if no contextId
-        const files = extractFilesFromChatHistory(chatHistory);
-        return files.map(f => f.url).filter(Boolean).join('\n') || 'No files available.';
+function getDefaultContext(agentContext) {
+    if (!agentContext || !Array.isArray(agentContext) || agentContext.length === 0) {
+        return null;
     }
+    return agentContext.find(ctx => ctx.default === true) || agentContext[0] || null;
+}
 
-    // Sync files from chat history to collection
-    await syncFilesToCollection(chatHistory, contextId, contextKey);
+/**
+ * Load merged file collection from agentContext array
+ * Merges all contexts in the array for read operations
+ * @param {Array} agentContext - Array of context objects { contextId, contextKey, default }
+ * @returns {Promise<Array>} Merged file collection
+ */
+async function loadMergedFileCollection(agentContext) {
+    if (!agentContext || !Array.isArray(agentContext) || agentContext.length === 0) {
+        return [];
+    }
+    
+    // Load first context as primary - use loadFileCollectionAll to get all files (not filtered by inCollection)
+    const primaryCtx = agentContext[0];
+    const primaryCollection = await loadFileCollectionAll(primaryCtx.contextId, primaryCtx.contextKey || null);
+    
+    // Tag primary files with their source context
+    const collection = primaryCollection.map(f => ({ ...f, _contextId: primaryCtx.contextId }));
+    
+    // If only one context, return early
+    if (agentContext.length === 1) {
+        return collection;
+    }
+    
+    // Load and merge additional contexts
+    for (let i = 1; i < agentContext.length; i++) {
+        const ctx = agentContext[i];
+        if (!ctx.contextId) continue;
+        
+        // Load alternate collection - use loadFileCollectionAll to bypass inCollection filtering
+        // (we want ALL files from the alt context, not just global ones)
+        const altCollection = await loadFileCollectionAll(ctx.contextId, ctx.contextKey || null);
+        
+        // Build set of existing identifiers from current collection
+        const existingHashes = new Set(collection.map(f => f.hash).filter(Boolean));
+        const existingUrls = new Set(collection.map(f => f.url).filter(Boolean));
+        const existingGcs = new Set(collection.map(f => f.gcs).filter(Boolean));
+        
+        // Add files from alt collection that aren't already in collection, tagged with alt context
+        for (const file of altCollection) {
+            const isDupe = (file.hash && existingHashes.has(file.hash)) ||
+                           (file.url && existingUrls.has(file.url)) ||
+                           (file.gcs && existingGcs.has(file.gcs));
+            if (!isDupe) {
+                collection.push({ ...file, _contextId: ctx.contextId });
+            }
+        }
+    }
     
-    // Return formatted files from collection
-    return await getAvailableFilesFromCollection(contextId, contextKey);
+    return collection;
 }
 
 /**
- * Sync files from chat history to collection and strip file content from messages.
- * Files are synced to the collection where they can be accessed via tools (AnalyzeFile, ReadTextFile, etc.)
- * File content is replaced with placeholders to avoid sending large files to the model.
+ * Get available files from file collection (no syncing from chat history)
+ * @param {Array} chatHistory - Unused, kept for API compatibility
+ * @param {Array} agentContext - Array of context objects { contextId, contextKey, default }
+ * @returns {Promise<string>} Formatted string of available files
+ */
+async function getAvailableFiles(chatHistory, agentContext) {
+    if (!agentContext || !Array.isArray(agentContext) || agentContext.length === 0) {
+        return 'No files available.';
+    }
+    const collection = await loadMergedFileCollection(agentContext);
+    // Strip internal _contextId before formatting
+    const cleanCollection = collection.map(({ _contextId, ...file }) => file);
+    return formatFilesForTemplate(cleanCollection);
+}
+
+/**
+ * Process files in chat history:
+ * - Files IN collection (all agentContext contexts): update lastAccessed, strip from message (tools can access)
+ * - Files NOT in collection: leave in message (model sees directly)
+ * 
  * @param {Array} chatHistory - Chat history array
- * @param {string} contextId - Context ID for file collection
- * @param {string|null} contextKey - Optional encryption key
- * @returns {Promise<{chatHistory: Array, availableFiles: string}>} Modified chat history and available files string
+ * @param {Array} agentContext - Array of context objects { contextId, contextKey, default }
+ * @returns {Promise<{chatHistory: Array, availableFiles: string}>}
  */
-async function syncAndStripFilesFromChatHistory(chatHistory, contextId, contextKey = null) {
+async function syncAndStripFilesFromChatHistory(chatHistory, agentContext) {
     if (!chatHistory || !Array.isArray(chatHistory)) {
         return { chatHistory: chatHistory || [], availableFiles: 'No files available.' };
     }
 
-    if (!contextId) {
-        // No contextId - can't sync to collection, just strip files
-        const strippedHistory = stripAllFilesFromChatHistory(chatHistory);
-        return { chatHistory: strippedHistory, availableFiles: 'No files available.' };
+    if (!agentContext || !Array.isArray(agentContext) || agentContext.length === 0) {
+        // No agentContext - no collection to check, leave all files in messages
+        return { chatHistory, availableFiles: 'No files available.' };
     }
 
-    // Sync files to collection first
-    await syncFilesToCollection(chatHistory, contextId, contextKey);
-    
-    // Get available files string
-    const availableFiles = await getAvailableFilesFromCollection(contextId, contextKey);
+    // Load merged collection once
+    const collection = await loadMergedFileCollection(agentContext);
     
-    // Strip all file content from chat history
-    const strippedHistory = stripAllFilesFromChatHistory(chatHistory);
+    // Build lookup map from contextId to contextKey for updates
+    const contextKeyMap = new Map(agentContext.map(ctx => [ctx.contextId, ctx.contextKey || null]));
     
-    return { chatHistory: strippedHistory, availableFiles };
-}
+    // Build lookup maps for fast matching and context lookup (need Maps, not Sets, to get full file object)
+    const collectionByHash = new Map(collection.filter(f => f.hash).map(f => [f.hash, f]));
+    const collectionByUrl = new Map(collection.filter(f => f.url).map(f => [f.url, f]));
+    const collectionByGcs = new Map(collection.filter(f => f.gcs).map(f => [f.gcs, f]));
 
-/**
- * Strip all file and image content from chat history, replacing with placeholders.
- * @param {Array} chatHistory - Chat history array
- * @returns {Array} Chat history with file content replaced by placeholders
- */
-function stripAllFilesFromChatHistory(chatHistory) {
-    if (!chatHistory || !Array.isArray(chatHistory)) {
-        return chatHistory || [];
-    }
+    // Helper to get file from collection (by hash, URL, or GCS) to find _contextId
+    const getFileFromCollection = (contentObj) => {
+        const fileHash = contentObj.hash;
+        const fileUrl = contentObj.url || contentObj.image_url?.url;
+        const fileGcs = contentObj.gcs;
+        
+        if (fileHash && collectionByHash.has(fileHash)) {
+            return collectionByHash.get(fileHash);
+        }
+        if (fileUrl && collectionByUrl.has(fileUrl)) {
+            return collectionByUrl.get(fileUrl);
+        }
+        if (fileGcs && collectionByGcs.has(fileGcs)) {
+            return collectionByGcs.get(fileGcs);
+        }
+        return null;
+    };
+
+    // Helper to check if a file content object is in the collection
+    const isInCollection = (contentObj) => {
+        return getFileFromCollection(contentObj) !== null;
+    };
+    
+    // Helper to update file when stripped - use _contextId from collection to know which context to update
+    const updateStrippedFile = (contentObj) => {
+        const file = getFileFromCollection(contentObj);
+        if (!file || !file._contextId) return;
+        
+        // Use hash from the found file (may not be in contentObj)
+        const hash = file.hash;
+        if (!hash) return;
+        
+        // Get the correct contextKey for this file's context
+        const fileContextKey = contextKeyMap.get(file._contextId) || null;
+        
+        const now = new Date().toISOString();
+        updateFileMetadata(file._contextId, hash, {
+            lastAccessed: now,
+            inCollection: ['*']
+        }, fileContextKey).catch((err) => {
+            logger.warn(`Failed to update metadata for stripped file (hash=${hash}): ${err?.message || err}`);
+        });
+    };
 
-    return chatHistory.map(message => {
+    // Process chat history - only strip files that are in collection
+    const processedHistory = chatHistory.map(message => {
         if (!message || message.role !== 'user' || !message.content) {
             return message;
         }
@@ -1502,9 +1509,14 @@ function stripAllFilesFromChatHistory(chatHistory) {
             const newContent = message.content.map(item => {
                 const contentObj = typeof item === 'string' ? tryParseJson(item) : item;
                 if (contentObj && (contentObj.type === 'image_url' || contentObj.type === 'file')) {
-                    // Extract filename for placeholder
-                    const filename = extractFilenameFromFileContent(contentObj);
-                    return { type: 'text', text: `[File: ${filename} - available via file tools]` };
+                    if (isInCollection(contentObj)) {
+                        // In collection - strip and update metadata
+                        updateStrippedFile(contentObj); // fire and forget
+                        const filename = extractFilenameFromFileContent(contentObj);
+                        return { type: 'text', text: `[File: ${filename} - available via file tools]` };
+                    }
+                    // Not in collection - leave as-is
+                    return item;
                 }
                 return item;
             });
@@ -1514,8 +1526,11 @@ function stripAllFilesFromChatHistory(chatHistory) {
         // Handle object content
         if (typeof message.content === 'object' && message.content !== null) {
             if (message.content.type === 'image_url' || message.content.type === 'file') {
-                const filename = extractFilenameFromFileContent(message.content);
-                return { ...message, content: `[File: ${filename} - available via file tools]` };
+                if (isInCollection(message.content)) {
+                    updateStrippedFile(message.content); // fire and forget
+                    const filename = extractFilenameFromFileContent(message.content);
+                    return { ...message, content: `[File: ${filename} - available via file tools]` };
+                }
             }
         }
 
@@ -1523,13 +1538,21 @@ function stripAllFilesFromChatHistory(chatHistory) {
         if (typeof message.content === 'string') {
             const contentObj = tryParseJson(message.content);
             if (contentObj && (contentObj.type === 'image_url' || contentObj.type === 'file')) {
-                const filename = extractFilenameFromFileContent(contentObj);
-                return { ...message, content: `[File: ${filename} - available via file tools]` };
+                if (isInCollection(contentObj)) {
+                    updateStrippedFile(contentObj); // fire and forget
+                    const filename = extractFilenameFromFileContent(contentObj);
+                    return { ...message, content: `[File: ${filename} - available via file tools]` };
+                }
             }
         }
 
         return message;
     });
+
+    // Strip internal _contextId before formatting (it's only needed for updates)
+    const cleanCollection = collection.map(({ _contextId, ...file }) => file);
+    const availableFiles = formatFilesForTemplate(cleanCollection);
+    return { chatHistory: processedHistory, availableFiles };
 }
 
 /**
@@ -1661,15 +1684,15 @@ function findFileInCollection(fileParam, collection) {
 /**
  * Resolve a file parameter to a URL by looking it up in the file collection
  * If the parameter is already a URL (starts with http:// or https://), returns it as-is
- * If contextId is provided, looks up the file in the collection and returns its URL
+ * If agentContext is provided, looks up the file in the merged collection and returns its URL
  * @param {string} fileParam - File ID, URL (Azure or GCS), hash, or filename from collection
- * @param {string} contextId - Context ID for the file collection
- * @param {string} contextKey - Optional context key for encryption
+ * @param {Array} agentContext - Array of context objects { contextId, contextKey, default }
  * @param {Object} options - Optional configuration
  * @param {boolean} options.preferGcs - If true, prefer GCS URL over Azure URL when available
+ * @param {boolean} options.useCache - If false, bypass cache (default: true, only used for single context)
  * @returns {Promise<string|null>} Resolved file URL, or null if not found
  */
-export async function resolveFileParameter(fileParam, contextId, contextKey = null, options = {}) {
+export async function resolveFileParameter(fileParam, agentContext, options = {}) {
     if (!fileParam || typeof fileParam !== 'string') {
         return null;
     }
@@ -1677,15 +1700,16 @@ export async function resolveFileParameter(fileParam, contextId, contextKey = nu
     const trimmed = fileParam.trim();
     const { preferGcs = false, useCache = true } = options;
 
-    // If no contextId, can't look up in collection - return null
-    if (!contextId) {
+    // If no agentContext, can't look up in collection - return null
+    if (!agentContext || !Array.isArray(agentContext) || agentContext.length === 0) {
         return null;
     }
 
     try {
-        // Load file collection and find the file
-        // useCache can be set to false to bypass cache (e.g., after file edits)
-        const collection = await loadFileCollection(contextId, contextKey, useCache);
+        // Load merged file collection (always use merged to get all files, not just global ones)
+        // Note: useCache option is ignored for merged collections (they always load fresh)
+        const collection = await loadMergedFileCollection(agentContext);
+        
         const foundFile = findFileInCollection(trimmed, collection);
         
         if (foundFile) {
@@ -1711,11 +1735,10 @@ export async function resolveFileParameter(fileParam, contextId, contextKey = nu
 /**
  * Generate file message content by looking up a file parameter in the file collection
  * @param {string} fileParam - File URL (Azure or GCS), file ID from collection, or file hash
- * @param {string} contextId - Context ID for the file collection
- * @param {string} contextKey - Optional context key for encryption
+ * @param {Array} agentContext - Array of context objects { contextId, contextKey, default }
  * @returns {Promise<Object|null>} Content object in the format for chat history, or null if not found
  */
-async function generateFileMessageContent(fileParam, contextId, contextKey = null) {
+async function generateFileMessageContent(fileParam, agentContext) {
     if (!fileParam || typeof fileParam !== 'string') {
         return null;
     }
@@ -1736,14 +1759,13 @@ async function generateFileMessageContent(fileParam, contextId, contextKey = nul
         logger.debug(`YouTube URL check failed for "${fileParam}": ${error.message}`);
     }
 
-    if (!contextId) {
-        // Without contextId, we can't look up in collection
-        // Return a basic content object from the URL
+    if (!agentContext || !Array.isArray(agentContext) || agentContext.length === 0) {
+        // Without agentContext, we can't look up in collection
         return null;
     }
 
-    // Load file collection
-    const collection = await loadFileCollection(contextId, contextKey, true);
+    // Load merged file collection
+    const collection = await loadMergedFileCollection(agentContext);
 
     // Find the file using shared matching logic
     const foundFile = findFileInCollection(fileParam, collection);
@@ -1754,8 +1776,9 @@ async function generateFileMessageContent(fileParam, contextId, contextKey = nul
     }
 
     // Resolve to short-lived URL if possible
-    // Pass contextId to ensure files are found in the correct context scope
-    const fileWithShortLivedUrl = await ensureShortLivedUrl(foundFile, MEDIA_API_URL, contextId);
+    // Use default context for ensureShortLivedUrl
+    const defaultCtx = getDefaultContext(agentContext);
+    const fileWithShortLivedUrl = await ensureShortLivedUrl(foundFile, MEDIA_API_URL, defaultCtx?.contextId || null);
 
     return {
         type: 'image_url',
@@ -2393,8 +2416,9 @@ export {
     markCompletedForCleanUp,
     extractFileMetadataFromContent,
     extractFilesFromChatHistory,
-    syncFilesToCollection,
     getAvailableFilesFromCollection,
+    getDefaultContext,
+    loadMergedFileCollection,
     formatFilesForTemplate,
     getAvailableFiles,
     syncAndStripFilesFromChatHistory,
@@ -2404,6 +2428,7 @@ export {
     injectFileIntoChatHistory,
     addFileToCollection,
     loadFileCollection,
+    loadFileCollectionAll,
     saveFileCollection,
     updateFileMetadata,
     getCollectionCacheKey,

package/lib/requestExecutor.js

@@ -6,6 +6,7 @@ import { setupCache } from 'axios-cache-interceptor';
 import Redis from 'ioredis';
 import logger from './logger.js';
 import { v4 as uuidv4 } from 'uuid';
+import { sanitizeBase64 } from './util.js';
 
 const connectionString = config.get('storageConnectionString');
 
@@ -229,10 +230,10 @@ const requestWithMonitor = async (endpoint, url, data, axiosConfigObj) => {
     let response;
     try {
         if (axiosConfigObj?.method == 'GET'){
-            logger.debug(`Getting ${url} with data: ${JSON.stringify(data)}`);
+            logger.debug(`Getting ${url} with data: ${JSON.stringify(sanitizeBase64(data))}`);
             response = await cortexAxios.get(url, axiosConfigObj);
         } else {
-            logger.debug(`Posting ${url} with data: ${JSON.stringify(data)}`);
+            logger.debug(`Posting ${url} with data: ${JSON.stringify(sanitizeBase64(data))}`);
             response = await cortexAxios.post(url, data, axiosConfigObj);
         }
     } catch (error) {