@aj-archipelago/cortex 1.4.30 → 1.4.32

package/lib/fileUtils.js

@@ -507,17 +507,24 @@ function extractFilesFromChatHistory(chatHistory) {
  */
 function isFileInCollection(inCollection, chatId = null) {
     // If not set, file is not in collection
+    // Treat empty array [] the same as undefined (not in collection)
+    // Note: false is not a valid value (normalizes to undefined), but handle it defensively
     if (inCollection === undefined || inCollection === null || inCollection === false) {
         return false;
     }
     
+    // Empty array means not in collection (same as undefined)
+    if (Array.isArray(inCollection) && inCollection.length === 0) {
+        return false;
+    }
+    
     // Backward compatibility: boolean true means global
     if (inCollection === true) {
         return true;
     }
     
     // Array format: check if it includes '*' (global) or the specific chatId
-    if (Array.isArray(inCollection)) {
+    if (Array.isArray(inCollection) && inCollection.length > 0) {
         // If no chatId specified, only include global files
         if (chatId === null) {
             return inCollection.includes('*');
@@ -699,125 +706,180 @@ function parseRawFileData(allFiles, contextKey = null) {
 }
 
 /**
- * Filter and format file collection based on inCollection and chatId
- * @param {Array} rawFiles - Array of parsed file data objects
- * @param {string|null} chatId - Optional chat ID to filter by
- * @returns {Array} Filtered and sorted file collection (includes inCollection for reference counting)
+ * Sort files by lastAccessed (most recent first)
+ * @param {Array} files - Array of file objects
+ * @returns {Array} Sorted array
  */
-function filterAndFormatFileCollection(rawFiles, chatId = null) {
-    // Filter by inCollection and optional chatId
-    const filtered = rawFiles.filter(file => isFileInCollection(file.inCollection, chatId));
-    
-    // Keep inCollection in output (needed for reference counting display)
-    // Sort by lastAccessed (most recent first)
-    filtered.sort((a, b) => {
+function sortFilesByLastAccessed(files) {
+    return files.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 filtered;
 }
 
-async function loadFileCollection(contextId, contextKey = null, useCache = true, chatId = null) {
-    if (!contextId) {
+/**
+ * Load file collection from one or more contexts (unified function)
+ * 
+ * @param {Array|Object|string} agentContext - Context(s) to load from:
+ *   - Array of {contextId, contextKey, default} objects (compound context)
+ *   - Single {contextId, contextKey, default} object
+ *   - String contextId (contextKey will be null)
+ * @param {Object} options - Load options
+ * @param {Array<string>|string|null} options.chatIds - Chat IDs to filter by:
+ *   - If null/undefined/empty array: return ALL files regardless of inCollection
+ *   - If provided: filter to files where inCollection includes '*' or any of these chatIds
+ * @param {boolean} options.useCache - Whether to use cache (default: true)
+ * @returns {Promise<Array>} File collection (deduplicated across contexts, sorted by lastAccessed)
+ */
+async function loadFileCollection(agentContext, options = {}) {
+    // Normalize agentContext to array format
+    let contexts = [];
+    if (typeof agentContext === 'string') {
+        // Single contextId string
+        contexts = [{ contextId: agentContext, contextKey: null, default: true }];
+    } else if (Array.isArray(agentContext)) {
+        contexts = agentContext.filter(ctx => ctx && ctx.contextId);
+    } else if (agentContext && typeof agentContext === 'object' && agentContext.contextId) {
+        // Single context object
+        contexts = [agentContext];
+    }
+    
+    if (contexts.length === 0) {
         return [];
     }
-
-    const cacheKey = getCollectionCacheKey(contextId, contextKey);
-
-    // Check cache first - cache stores raw parsed file data, so we can filter by chatId from cache
-    if (useCache && fileCollectionCache.has(cacheKey)) {
-        const cached = fileCollectionCache.get(cacheKey);
-        if (Date.now() - cached.timestamp < CACHE_TTL) {
-            // Apply filtering to cached raw data
-            return filterAndFormatFileCollection(cached.rawFiles, chatId);
-        }
+    
+    // Normalize options
+    const useCache = options.useCache !== false; // default true
+    let chatIds = options.chatIds;
+    
+    // Normalize chatIds to array or null
+    if (chatIds === undefined || chatIds === null) {
+        chatIds = null; // No filtering
+    } else if (typeof chatIds === 'string') {
+        chatIds = chatIds.trim() ? [chatIds] : null;
+    } else if (Array.isArray(chatIds)) {
+        chatIds = chatIds.filter(id => id && typeof id === 'string' && id.trim());
+        if (chatIds.length === 0) chatIds = null;
+    } else {
+        chatIds = null;
     }
-
-    // Load from context-scoped Redis hash map (FileStoreMap:ctx:<contextId>)
-    let rawFiles = [];
     
-    try {
-        const redisClient = await getRedisClient();
+    // Load files from all contexts
+    let allFiles = [];
+    
+    for (const ctx of contexts) {
+        const contextId = ctx.contextId;
+        const contextKey = ctx.contextKey || null;
+        const cacheKey = getCollectionCacheKey(contextId, contextKey);
         
-        if (redisClient) {
-            const contextMapKey = `FileStoreMap:ctx:${contextId}`;
-            const allFiles = await redisClient.hgetall(contextMapKey);
-            
-            // Parse raw file data (preserves inCollection metadata for filtering)
-            // Pass contextKey for decryption
-            rawFiles = parseRawFileData(allFiles, contextKey);
+        let rawFiles = [];
+        
+        // Check cache first
+        if (useCache && fileCollectionCache.has(cacheKey)) {
+            const cached = fileCollectionCache.get(cacheKey);
+            if (Date.now() - cached.timestamp < CACHE_TTL) {
+                rawFiles = cached.rawFiles;
+            }
         }
-    } catch (e) {
-        // Collection doesn't exist yet or error reading, start with empty array
-        rawFiles = [];
-    }
-
-    // Update cache with raw file data (supports any filtering on retrieval)
-    if (useCache) {
-        fileCollectionCache.set(cacheKey, {
-            rawFiles: rawFiles,
-            timestamp: Date.now()
-        });
-    }
-
-    // Filter and format for return
-    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 (keep inCollection for reference counting)
-            // Sort by lastAccessed (most recent first)
-            rawFiles.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 rawFiles;
+        // Load from Redis if not cached
+        if (rawFiles.length === 0) {
+            try {
+                const redisClient = await getRedisClient();
+                if (redisClient) {
+                    const contextMapKey = `FileStoreMap:ctx:${contextId}`;
+                    const filesData = await redisClient.hgetall(contextMapKey);
+                    rawFiles = parseRawFileData(filesData, contextKey);
+                    
+                    // Update cache
+                    if (useCache) {
+                        fileCollectionCache.set(cacheKey, {
+                            rawFiles: rawFiles,
+                            timestamp: Date.now()
+                        });
+                    }
+                }
+            } catch (e) {
+                // Collection doesn't exist yet or error reading
+                rawFiles = [];
+            }
         }
-    } catch (e) {
-        // Collection doesn't exist yet or error reading
+        
+        // Tag files with their source context
+        allFiles.push(...rawFiles.map(f => ({ ...f, _contextId: contextId })));
+    }
+    
+    // Deduplicate by hash/url/gcs (keep first occurrence - primary context wins)
+    const seenHashes = new Set();
+    const seenUrls = new Set();
+    const seenGcs = new Set();
+    const deduped = [];
+    
+    for (const file of allFiles) {
+        const isDupe = (file.hash && seenHashes.has(file.hash)) ||
+                       (file.url && seenUrls.has(file.url)) ||
+                       (file.gcs && seenGcs.has(file.gcs));
+        if (!isDupe) {
+            if (file.hash) seenHashes.add(file.hash);
+            if (file.url) seenUrls.add(file.url);
+            if (file.gcs) seenGcs.add(file.gcs);
+            deduped.push(file);
+        }
+    }
+    
+    // Apply filtering
+    let filtered;
+    if (chatIds !== null) {
+        // Filter to files that are in collection for any of the provided chatIds
+        filtered = deduped.filter(file => {
+            // Check if file is accessible for any of the chatIds
+            for (const chatId of chatIds) {
+                if (isFileInCollection(file.inCollection, chatId)) {
+                    return true;
+                }
+            }
+            return false;
+        });
+    } else {
+        // If chatIds is null, return ALL files
+        // Valid inCollection is an array with strings (or boolean true for backward compat)
+        // Files with inCollection === undefined/null/[] are included (Labeeb uploads, not in collection - treat the same)
+        // Note: false is not a valid value (normalizes to undefined), so we shouldn't see it in data
+        filtered = deduped.filter(file => {
+            const ic = file.inCollection;
+            // Include undefined/null/empty array (Labeeb uploads, not in collection - treat the same)
+            if (ic === undefined || ic === null || (Array.isArray(ic) && ic.length === 0)) return true;
+            // Include boolean true (backward compat - global)
+            if (ic === true) return true;
+            // Include valid arrays (non-empty arrays with strings)
+            if (Array.isArray(ic) && ic.length > 0) return true;
+            // Exclude everything else (invalid formats - defensive programming)
+            return false;
+        });
     }
     
-    return [];
+    return sortFilesByLastAccessed(filtered);
 }
 
 /**
  * Normalize inCollection value to array format
  * @param {boolean|Array<string>|undefined} inCollection - inCollection value to normalize
- * @returns {Array<string>|undefined} Normalized array or undefined if false/null
+ * @returns {Array<string>|undefined} Normalized array, or undefined if false/null/undefined/empty array
  */
 function normalizeInCollection(inCollection) {
-    // If explicitly false or null, return undefined (file not in collection)
-    if (inCollection === false || inCollection === null) {
+    // If explicitly false, return undefined (not in collection, same as undefined)
+    if (inCollection === false) {
         return undefined;
     }
     
-    // If undefined, return undefined (preserve existing state)
-    if (inCollection === undefined) {
+    // If null or undefined, return undefined (file not in collection)
+    if (inCollection === null || inCollection === undefined) {
+        return undefined;
+    }
+    
+    // If empty array, return undefined (not in collection, same as undefined)
+    if (Array.isArray(inCollection) && inCollection.length === 0) {
         return undefined;
     }
     
@@ -947,6 +1009,7 @@ async function updateFileMetadata(contextId, hash, metadata, contextKey = null,
         const fileData = {
             ...existingData, // Preserve all CFH data (url, gcs, hash, filename, etc.)
             // Handle inCollection: normalize if provided, otherwise preserve existing or default based on chatId
+            // normalizeInCollection converts false/null/undefined/[] to undefined (no collection membership)
             inCollection: metadata.inCollection !== undefined
                 ? normalizeInCollection(metadata.inCollection)
                 : (existingData.inCollection !== undefined
@@ -964,6 +1027,7 @@ async function updateFileMetadata(contextId, hash, metadata, contextKey = null,
         };
         
         // Remove inCollection if it's undefined (file not in collection)
+        // Empty arrays [] are normalized to undefined, so they get deleted too
         if (fileData.inCollection === undefined) {
             delete fileData.inCollection;
         }
@@ -1377,7 +1441,7 @@ async function getAvailableFilesFromCollection(contextId, contextKey = null) {
         return 'No files available.';
     }
 
-    const collection = await loadFileCollection(contextId, contextKey, true);
+    const collection = await loadFileCollection({ contextId, contextKey, default: true });
     return formatFilesForTemplate(collection);
 }
 
@@ -1440,81 +1504,6 @@ function getDefaultContext(agentContext) {
     return agentContext.find(ctx => ctx.default === true) || agentContext[0] || null;
 }
 
-/**
- * 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 }
- * @param {string|null} chatId - Optional chat ID to filter files by (if provided, only includes files with '*' or this chatId in inCollection)
- * @returns {Promise<Array>} Merged file collection
- */
-async function loadMergedFileCollection(agentContext, chatId = null) {
-    if (!agentContext || !Array.isArray(agentContext) || agentContext.length === 0) {
-        return [];
-    }
-    
-    // Load first context as primary
-    // If chatId is provided, use loadFileCollection to filter by chatId
-    // Otherwise, use loadFileCollectionAll to get all files (we'll filter by inCollection below)
-    const primaryCtx = agentContext[0];
-    const primaryCollection = chatId 
-        ? await loadFileCollection(primaryCtx.contextId, primaryCtx.contextKey || null, true, chatId)
-        : await loadFileCollectionAll(primaryCtx.contextId, primaryCtx.contextKey || null);
-    
-    // Tag primary files with their source context
-    let collection = primaryCollection.map(f => ({ ...f, _contextId: primaryCtx.contextId }));
-    
-    // Load and merge additional contexts
-    for (let i = 1; i < agentContext.length; i++) {
-        const ctx = agentContext[i];
-        if (!ctx.contextId) continue;
-        
-        // Load alternate collection
-        // If chatId is provided, use loadFileCollection to filter by chatId
-        // Otherwise, use loadFileCollectionAll to get all files
-        const altCollection = chatId
-            ? await loadFileCollection(ctx.contextId, ctx.contextKey || null, true, chatId)
-            : 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 });
-            }
-        }
-    }
-    
-    // When chatId is null (includeAllChats=true), filter to only include files with inCollection set
-    // Agent tools should only see files that are actually in the collection (have inCollection set)
-    if (chatId === null) {
-        collection = collection.filter(file => {
-            const inCollection = file.inCollection;
-            
-            // Exclude files without inCollection set or with empty inCollection array/string
-            if (inCollection === undefined || inCollection === null || inCollection === false || inCollection === '') {
-                return false;
-            }
-            
-            // Exclude empty arrays (file not in any collection)
-            if (Array.isArray(inCollection) && inCollection.length === 0) {
-                return false;
-            }
-            
-            // Include files with inCollection set (truthy and non-empty)
-            return true;
-        });
-    }
-    
-    return collection;
-}
-
 /**
  * Get available files from file collection (no syncing from chat history)
  * @param {Array} chatHistory - Unused, kept for API compatibility
@@ -1525,7 +1514,8 @@ async function getAvailableFiles(chatHistory, agentContext) {
     if (!agentContext || !Array.isArray(agentContext) || agentContext.length === 0) {
         return 'No files available.';
     }
-    const collection = await loadMergedFileCollection(agentContext);
+    // Load all files from all contexts (no chatIds = no filtering)
+    const collection = await loadFileCollection(agentContext);
     // Strip internal _contextId before formatting
     const cleanCollection = collection.map(({ _contextId, ...file }) => file);
     return formatFilesForTemplate(cleanCollection);
@@ -1551,16 +1541,32 @@ async function syncAndStripFilesFromChatHistory(chatHistory, agentContext, chatI
         return { chatHistory, availableFiles: 'No files available.' };
     }
 
-    // Load merged collection once
-    const collection = await loadMergedFileCollection(agentContext);
+    // Load ALL files from all contexts (no chatIds = no filtering)
+    // This finds files even if they don't have inCollection set (Labeeb uploads)
+    const allFiles = await loadFileCollection(agentContext);
+    
+    // For availableFiles output, filter to only files with inCollection set
+    const collection = chatId 
+        ? await loadFileCollection(agentContext, { chatIds: [chatId] })
+        : allFiles.filter(file => {
+            const inCollection = file.inCollection;
+            if (inCollection === undefined || inCollection === null || inCollection === false || inCollection === '') {
+                return false;
+            }
+            if (Array.isArray(inCollection) && inCollection.length === 0) {
+                return false;
+            }
+            return true;
+        });
     
     // Build lookup map from contextId to contextKey for updates
     const contextKeyMap = new Map(agentContext.map(ctx => [ctx.contextId, ctx.contextKey || null]));
     
-    // 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]));
+    // Build lookup maps for fast matching and context lookup (use ALL files, not just filtered)
+    // This allows us to find files that exist in Redis but don't have inCollection set yet
+    const collectionByHash = new Map(allFiles.filter(f => f.hash).map(f => [f.hash, f]));
+    const collectionByUrl = new Map(allFiles.filter(f => f.url).map(f => [f.url, f]));
+    const collectionByGcs = new Map(allFiles.filter(f => f.gcs).map(f => [f.gcs, f]));
 
     // Helper to get file from collection (by hash, URL, or GCS) to find _contextId
     const getFileFromCollection = (contentObj) => {
@@ -1600,11 +1606,14 @@ async function syncAndStripFilesFromChatHistory(chatHistory, agentContext, chatI
         const now = new Date().toISOString();
         // Update lastAccessed and add chatId to inCollection (reference counting)
         // If this file is being used in a new chat, add that chat to the list
-        const updatedInCollection = addChatIdToInCollection(file.inCollection, chatId);
+        // If file doesn't have inCollection set yet (e.g., uploaded by Labeeb), initialize it
+        const updatedInCollection = file.inCollection 
+            ? addChatIdToInCollection(file.inCollection, chatId)
+            : getInCollectionValue(chatId);
         updateFileMetadata(file._contextId, hash, {
             lastAccessed: now,
             inCollection: updatedInCollection
-        }, fileContextKey).catch((err) => {
+        }, fileContextKey, chatId).catch((err) => {
             logger.warn(`Failed to update metadata for stripped file (hash=${hash}): ${err?.message || err}`);
         });
     };
@@ -1626,8 +1635,8 @@ async function syncAndStripFilesFromChatHistory(chatHistory, agentContext, chatI
                         const filename = extractFilenameFromFileContent(contentObj);
                         return { type: 'text', text: `[File: ${filename} - available via file tools]` };
                     }
-                    // Not in collection - leave as-is
-                    return item;
+                    // Not in collection - leave as-is (use parsed object if it was parsed from string)
+                    return contentObj;
                 }
                 return item;
             });
@@ -1817,9 +1826,8 @@ export async function resolveFileParameter(fileParam, agentContext, options = {}
     }
 
     try {
-        // 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);
+        // Load all files from all contexts (no chatIds = no filtering)
+        const collection = await loadFileCollection(agentContext);
         
         const foundFile = findFileInCollection(trimmed, collection);
         
@@ -1875,8 +1883,9 @@ async function generateFileMessageContent(fileParam, agentContext) {
         return null;
     }
 
-    // Load merged file collection
-    const collection = await loadMergedFileCollection(agentContext);
+    // Load all files from all contexts (no chatIds = no filtering)
+    // Use useCache: false to ensure we get fresh data (important for recently added files)
+    const collection = await loadFileCollection(agentContext, { useCache: false });
 
     // Find the file using shared matching logic
     const foundFile = findFileInCollection(fileParam, collection);
@@ -2588,7 +2597,6 @@ export {
     extractFilesFromChatHistory,
     getAvailableFilesFromCollection,
     getDefaultContext,
-    loadMergedFileCollection,
     formatFilesForTemplate,
     getAvailableFiles,
     syncAndStripFilesFromChatHistory,
@@ -2598,7 +2606,6 @@ export {
     injectFileIntoChatHistory,
     addFileToCollection,
     loadFileCollection,
-    loadFileCollectionAll,
     saveFileCollection,
     updateFileMetadata,
     getCollectionCacheKey,

package/lib/pathwayManager.js

@@ -349,6 +349,7 @@ class PathwayManager {
     const promptName = typeof promptItem === 'string' ? defaultName : (promptItem.name || defaultName);
     const promptFiles = typeof promptItem === 'string' ? [] : (promptItem.files || []);
     const cortexPathwayName = typeof promptItem === 'string' ? null : (promptItem.cortexPathwayName || null);
+    const researchMode = typeof promptItem === 'string' ? undefined : (promptItem.researchMode !== undefined ? promptItem.researchMode : undefined);
     
     const messages = [];
 
@@ -383,6 +384,11 @@ class PathwayManager {
       prompt.cortexPathwayName = cortexPathwayName;
     }
 
+    // Preserve researchMode if present
+    if (researchMode !== undefined) {
+      prompt.researchMode = researchMode;
+    }
+
     return prompt;
   }
 
@@ -460,6 +466,7 @@ class PathwayManager {
       prompt: String!
       files: [String!]
       cortexPathwayName: String
+      researchMode: Boolean
     }
     
     input PathwayInput {

package/lib/pathwayTools.js

@@ -6,6 +6,7 @@ import { getSemanticChunks } from "../server/chunker.js";
 import logger from '../lib/logger.js';
 import { requestState } from '../server/requestState.js';
 import { processPathwayParameters } from '../server/typeDef.js';
+import { waitForClientToolResult } from '../server/clientToolCallbacks.js';
 
 // callPathway - call a pathway from another pathway
 const callPathway = async (pathwayName, inArgs, pathwayResolver) => {
@@ -91,6 +92,76 @@ const callTool = async (toolName, args, toolDefinitions, pathwayResolver) => {
     logger.debug(`callTool: Starting execution of ${toolName} ${JSON.stringify(logArgs)}`);
 
     try {
+        // Check if this is a client-side tool
+        if (toolDef.clientSide === true || toolDef.definition?.clientSide === true) {
+            logger.info(`Tool ${toolName} is a client-side tool - waiting for client execution`);
+            
+            const toolCallbackId = `${toolName}_${Date.now()}_${Math.random().toString(36).substring(7)}`;
+            
+            // Explicitly publish the marker to the stream so the client receives it
+            if (pathwayResolver) {
+                const requestId = pathwayResolver.rootRequestId || pathwayResolver.requestId;
+                
+                const toolCallbackData = {
+                    toolUsed: [toolName],
+                    clientSideTool: true,
+                    toolCallbackName: toolName,
+                    toolCallbackId: toolCallbackId,
+                    toolCallbackMessage: args.userMessage || `Executing ${toolName}...`,
+                    chatId: args.chatId || "",
+                    requestId: requestId, // Include requestId so client can submit tool results
+                    toolArgs: args
+                };
+                
+                try {
+                    logger.info(`Publishing client-side tool marker to requestId: ${requestId}, toolCallbackId: ${toolCallbackId}`);
+                    await publishRequestProgress({
+                        requestId,
+                        progress: 0.5,
+                        data: JSON.stringify(""),
+                        info: JSON.stringify(toolCallbackData)
+                    });
+                } catch (error) {
+                    logger.error(`Error publishing client-side tool marker: ${error.message}`);
+                    throw error;
+                }
+                
+                // Wait for the client to execute the tool and send back the result
+                logger.info(`Waiting for client tool result: ${toolCallbackId}`);
+                try {
+                    // Use 5 minute timeout to accommodate longer operations like CreateApplet
+                    const clientResult = await waitForClientToolResult(toolCallbackId, requestId, 300000);
+                    logger.info(`Received client tool result for ${toolCallbackId}: ${JSON.stringify(clientResult).substring(0, 200)}`);
+                    
+                    // If the client reported an error, throw it
+                    if (!clientResult.success) {
+                        throw new Error(clientResult.error || 'Client tool execution failed');
+                    }
+                    
+                    // Return the client's result
+                    toolResult = typeof clientResult.data === 'string' 
+                        ? clientResult.data 
+                        : JSON.stringify(clientResult.data);
+                    
+                    // Update resolver with tool result
+                    pathwayResolver.tool = JSON.stringify({
+                        ...toolCallbackData,
+                        result: clientResult.data
+                    });
+                    
+                    return {
+                        result: toolResult,
+                        images: []
+                    };
+                } catch (error) {
+                    logger.error(`Error waiting for client tool result: ${error.message}`);
+                    throw new Error(`Client tool execution failed: ${error.message}`);
+                }
+            } else {
+                throw new Error('PathwayResolver is required for client-side tools');
+            }
+        }
+
         const pathwayName = toolDef.pathwayName;
         // Merge hard-coded pathway parameters with runtime args
         const mergedArgs = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aj-archipelago/cortex",
-  "version": "1.4.30",
+  "version": "1.4.32",
   "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/files/sys_read_file_collection.js

@@ -3,7 +3,7 @@
 // File collections are stored in Redis hash maps (FileStoreMap:ctx:<contextId>
 // Returns file collection as JSON array string for backward compatibility with Labeeb
 
-import { loadMergedFileCollection } from '../../../../lib/fileUtils.js';
+import { loadFileCollection } from '../../../../lib/fileUtils.js';
 
 export default {
     inputParameters: {
@@ -33,8 +33,8 @@ export default {
         }
         
         try {
-            // Load file collection from Redis hash maps (merged from all agentContext contexts)
-            const collection = await loadMergedFileCollection(agentContext);
+            // Load file collection from Redis hash maps (from all agentContext contexts)
+            const collection = await loadFileCollection(agentContext);
             
             // Return as JSON array string for backward compatibility with Labeeb
             // Labeeb expects either: [] or { version: "...", files: [...] }