@aj-archipelago/cortex 1.3.66 → 1.3.67

package/server/graphql.js

@@ -15,7 +15,6 @@ import { WebSocketServer } from 'ws';
 import responseCachePlugin from '@apollo/server-plugin-response-cache';
 import { KeyvAdapter } from '@apollo/utils.keyvadapter';
 import cors from 'cors';
-import { v4 as uuidv4 } from 'uuid';
 import { buildModels, buildPathways } from '../config.js';
 import logger from '../lib/logger.js';
 import { buildModelEndpoints } from '../lib/requestExecutor.js';
@@ -23,8 +22,9 @@ import { startTestServer } from '../tests/helpers/server.js';
 import { requestState } from './requestState.js';
 import { cancelRequestResolver } from './resolver.js';
 import subscriptions from './subscriptions.js';
-import { getMessageTypeDefs, getPathwayTypeDef, userPathwayInputParameters } from './typeDef.js';
+import { getMessageTypeDefs } from './typeDef.js';
 import { buildRestEndpoints } from './rest.js';
+import { executeWorkspaceResolver, getExecuteWorkspaceTypeDefs } from './executeWorkspace.js';
 
 // Utility functions
 // Server plugins
@@ -74,22 +74,7 @@ const getTypedefs = (pathways, pathwayManager) => {
         cancelRequest(requestId: String!): Boolean
     }
 
-    ${getPathwayTypeDef('ExecuteWorkspace', 'String')}
-    
-    type ExecuteWorkspaceResult {
-        debug: String
-        result: String
-        resultData: String
-        previousResult: String
-        warnings: [String]
-        errors: [String]
-        contextId: String
-        tool: String
-    }
-    
-    extend type Query {
-        executeWorkspace(userId: String!, pathwayName: String!, ${userPathwayInputParameters}): ExecuteWorkspaceResult
-    }
+    ${getExecuteWorkspaceTypeDefs()}
 
     type RequestSubscription {
         requestId: String
@@ -130,171 +115,11 @@ const getResolvers = (config, pathways, pathwayManager) => {
 
     const pathwayManagerResolvers = pathwayManager?.getResolvers() || {};
 
-    const executeWorkspaceResolver = async (_, args, contextValue, info) => {
-        const startTime = Date.now();
-        const requestId = uuidv4();
-        const { userId, pathwayName, promptNames, ...pathwayArgs } = args;
-        
-        logger.info(`>>> [${requestId}] executeWorkspace started - userId: ${userId}, pathwayName: ${pathwayName}, promptNames: ${promptNames?.join(',') || 'none'}`);
-        
-        try {
-            contextValue.config = config;
-            
-            // Get the base pathway from the user
-            const pathways = await pathwayManager.getLatestPathways();
-            
-            if (!pathways[userId] || !pathways[userId][pathwayName]) {
-                const error = new Error(`Pathway '${pathwayName}' not found for user '${userId}'`);
-                logger.error(`!!! [${requestId}] ${error.message} - Available users: ${Object.keys(pathways).join(', ')}`);
-                throw error;
-            }
-
-            const basePathway = pathways[userId][pathwayName];
-            logger.debug(`[${requestId}] Found pathway: ${pathwayName} for user: ${userId}`);
-            
-            // If promptNames is specified, use getPathways to get individual pathways and execute in parallel
-            if (promptNames && promptNames.length > 0) {
-                
-                // Check if the prompts are in legacy format (array of strings)
-                // If so, we can't use promptNames filtering and need to ask user to republish
-                if (pathwayManager.isLegacyPromptFormat(userId, pathwayName)) {
-                    const error = new Error(
-                        `The pathway '${pathwayName}' uses legacy prompt format (array of strings) which doesn't support the promptNames parameter. ` +
-                        `Please unpublish and republish your workspace to upgrade to the new format that supports named prompts.`
-                    );
-                    logger.error(`!!! [${requestId}] ${error.message}`);
-                    throw error;
-                }
-                
-                // Handle wildcard case - execute all prompts in parallel
-                if (promptNames.includes('*')) {
-                    logger.info(`[${requestId}] Executing all prompts in parallel (wildcard specified)`);
-                    const individualPathways = await pathwayManager.getPathways(basePathway);
-                    
-                    if (individualPathways.length === 0) {
-                        const error = new Error(`No prompts found in pathway '${pathwayName}'`);
-                        logger.error(`!!! [${requestId}] ${error.message}`);
-                        throw error;
-                    }
-                    
-                    // Execute all pathways in parallel
-                    logger.debug(`[${requestId}] Executing ${individualPathways.length} pathways in parallel`);
-                    const results = await Promise.all(
-                        individualPathways.map(async (pathway, index) => {
-                            try {
-                                logger.debug(`[${requestId}] Starting pathway ${index + 1}/${individualPathways.length}: ${pathway.name || 'unnamed'}`);
-                                const pathwayContext = { ...contextValue, pathway };
-                                const result = await pathway.rootResolver(null, pathwayArgs, pathwayContext, info);
-                                logger.debug(`[${requestId}] Completed pathway ${index + 1}/${individualPathways.length}: ${pathway.name || 'unnamed'}`);
-                                return {
-                                    result: result.result,
-                                    promptName: pathway.name || `prompt_${index + 1}`
-                                };
-                            } catch (error) {
-                                logger.error(`!!! [${requestId}] Error in pathway ${index + 1}/${individualPathways.length}: ${pathway.name || 'unnamed'} - ${error.message}`);
-                                logger.debug(`[${requestId}] Error stack: ${error.stack}`);
-                                throw error;
-                            }
-                        })
-                    );
-                    
-                    const duration = Date.now() - startTime;
-                    logger.info(`<<< [${requestId}] executeWorkspace completed successfully in ${duration}ms - returned ${results.length} results`);
-                    
-                    // Return a single result with JSON stringified array of results
-                    return {
-                        debug: `Executed ${results.length} prompts in parallel`,
-                        result: JSON.stringify(results),
-                        resultData: null,
-                        previousResult: null,
-                        warnings: [],
-                        errors: [],
-                        contextId: requestId,
-                        tool: 'executeWorkspace'
-                    };
-                } else {
-                    // Handle specific prompt names
-                    logger.info(`[${requestId}] Executing specific prompts: ${promptNames.join(', ')}`);
-                    const individualPathways = await pathwayManager.getPathways(basePathway, promptNames);
-                    
-                    if (individualPathways.length === 0) {
-                        const error = new Error(`No prompts found matching the specified names: ${promptNames.join(', ')}`);
-                        logger.error(`!!! [${requestId}] ${error.message}`);
-                        throw error;
-                    }
-                    
-                    // Execute all pathways in parallel
-                    logger.debug(`[${requestId}] Executing ${individualPathways.length} pathways in parallel`);
-                    const results = await Promise.all(
-                        individualPathways.map(async (pathway, index) => {
-                            try {
-                                logger.debug(`[${requestId}] Starting pathway ${index + 1}/${individualPathways.length}: ${pathway.name || 'unnamed'}`);
-                                const pathwayContext = { ...contextValue, pathway };
-                                const result = await pathway.rootResolver(null, pathwayArgs, pathwayContext, info);
-                                logger.debug(`[${requestId}] Completed pathway ${index + 1}/${individualPathways.length}: ${pathway.name || 'unnamed'}`);
-                                return {
-                                    result: result.result,
-                                    promptName: pathway.name || `prompt_${index + 1}`
-                                };
-                            } catch (error) {
-                                logger.error(`!!! [${requestId}] Error in pathway ${index + 1}/${individualPathways.length}: ${pathway.name || 'unnamed'} - ${error.message}`);
-                                logger.debug(`[${requestId}] Error stack: ${error.stack}`);
-                                throw error;
-                            }
-                        })
-                    );
-                    
-                    const duration = Date.now() - startTime;
-                    logger.info(`<<< [${requestId}] executeWorkspace completed successfully in ${duration}ms - returned ${results.length} results`);
-                    
-                    // Return a single result with JSON stringified array of results (consistent with wildcard case)
-                    return {
-                        debug: `Executed ${results.length} specific prompts in parallel: ${promptNames.join(', ')}`,
-                        result: JSON.stringify(results),
-                        resultData: null,
-                        previousResult: null,
-                        warnings: [],
-                        errors: [],
-                        contextId: requestId,
-                        tool: 'executeWorkspace'
-                    };
-                }
-            }
-            
-            // Default behavior: execute all prompts in sequence
-            logger.info(`[${requestId}] Executing prompts in sequence`);
-            const userPathway = await pathwayManager.getPathway(userId, pathwayName);
-            contextValue.pathway = userPathway;
-            
-            const result = await userPathway.rootResolver(null, pathwayArgs, contextValue, info);
-            const duration = Date.now() - startTime;
-            logger.info(`<<< [${requestId}] executeWorkspace completed successfully in ${duration}ms - returned 1 result`);
-            return result; // Return single result directly
-            
-        } catch (error) {
-            const duration = Date.now() - startTime;
-            logger.error(`!!! [${requestId}] executeWorkspace failed after ${duration}ms`);
-            logger.error(`!!! [${requestId}] Error type: ${error.constructor.name}`);
-            logger.error(`!!! [${requestId}] Error message: ${error.message}`);
-            logger.error(`!!! [${requestId}] Error stack: ${error.stack}`);
-            
-            // Log additional context for debugging "memory access out of bounds" errors
-            if (error.message && error.message.includes('memory')) {
-                logger.error(`!!! [${requestId}] MEMORY ERROR DETECTED - Additional context:`);
-                logger.error(`!!! [${requestId}] - Node.js version: ${process.version}`);
-                logger.error(`!!! [${requestId}] - Memory usage: ${JSON.stringify(process.memoryUsage())}`);
-                logger.error(`!!! [${requestId}] - Args size estimate: ${JSON.stringify(args).length} chars`);
-                logger.error(`!!! [${requestId}] - PathwayArgs keys: ${Object.keys(pathwayArgs).join(', ')}`);
-            }
-            
-            throw error;
-        }
-    };
-
     const resolvers = {
         Query: {
             ...resolverFunctions,
-            executeWorkspace: executeWorkspaceResolver
+            executeWorkspace: (parent, args, contextValue, info) => 
+                executeWorkspaceResolver(parent, args, contextValue, info, config, pathwayManager)
         },
         Mutation: {
             'cancelRequest': cancelRequestResolver,

package/tests/unit/core/parser.test.js

@@ -90,7 +90,6 @@ test('parseJson should attempt to repair invalid JSON', async t => {
     
     const result = await parser.parseJson(invalidJson);
     
-    console.log('parseJson result:', result);  // For debugging
     
     t.not(result, null);
     

package/tests/unit/core/pathwayManagerWithFiles.test.js

@@ -0,0 +1,256 @@
+/**
+ * PathwayManager File Handling Tests
+ * 
+ * This test suite validates the PathwayManager's file handling functionality, specifically
+ * testing how the manager processes and transforms pathway prompts that include file attachments.
+ * 
+ * Key functionality tested:
+ * - File hash transformation from 'files' to 'fileHashes' property
+ * - Collection and deduplication of file hashes at the pathway level
+ * - Backward compatibility with legacy string-based prompts without file attachments
+ * - Handling of edge cases (null, undefined, empty file arrays)
+ * - Prompt object creation with file metadata
+ * 
+ * The PathwayManager allows prompts to reference files by their hashes, which are then
+ * processed and made available to the execution context. This test suite ensures that
+ * file metadata is correctly preserved, transformed, and aggregated during pathway processing.
+ * 
+ * Test scenarios covered:
+ * 1. Prompts with multiple file attachments
+ * 2. Prompts with empty or missing file arrays
+ * 3. Legacy string prompts (no file support)
+ * 4. Duplicate file hash deduplication
+ * 5. Null/undefined file handling
+ * 6. Direct prompt object creation with files
+ */
+
+import test from 'ava';
+import PathwayManager from '../../../lib/pathwayManager.js';
+
+// Mock config for PathwayManager
+const mockConfig = {
+    storageType: 'local',
+    filePath: './test-pathways.json',
+    publishKey: 'test-key'
+};
+
+// Mock base pathway
+const mockBasePathway = {
+    name: 'base',
+    prompt: '{{text}}',
+    systemPrompt: '',
+    inputParameters: {},
+    typeDef: 'type Test { test: String }',
+    rootResolver: () => {},
+    resolver: () => {}
+};
+
+// Mock storage strategy
+class MockStorageStrategy {
+    async load() {
+        return {};
+    }
+    
+    async save(data) {
+        // Do nothing
+    }
+    
+    async getLastModified() {
+        return Date.now();
+    }
+}
+
+test('pathwayManager handles prompt format with files correctly', async t => {
+    const pathwayManager = new PathwayManager(mockConfig, mockBasePathway);
+    
+    // Replace storage with mock
+    pathwayManager.storage = new MockStorageStrategy();
+    
+    // Test prompts with files
+    const pathwayWithFiles = {
+        prompt: [
+            {
+                name: 'Analyze Document',
+                prompt: 'Please analyze the provided document',
+                files: ['abc123def456', 'def456ghi789']
+            },
+            {
+                name: 'Summarize Text',
+                prompt: 'Please summarize the text',
+                files: []
+            },
+            {
+                name: 'Simple Task',
+                prompt: 'Perform a simple task'
+                // No files property
+            }
+        ],
+        systemPrompt: 'You are a helpful assistant'
+    };
+    
+    // Test transformPrompts method
+    const transformedPathway = await pathwayManager.transformPrompts(pathwayWithFiles);
+    
+    // Verify the transformed pathway structure
+    t.truthy(transformedPathway);
+    t.true(Array.isArray(transformedPathway.prompt));
+    t.is(transformedPathway.prompt.length, 3);
+    
+    // Verify first prompt with files
+    const firstPrompt = transformedPathway.prompt[0];
+    t.is(firstPrompt.name, 'Analyze Document');
+    t.truthy(firstPrompt.fileHashes);
+    t.deepEqual(firstPrompt.fileHashes, ['abc123def456', 'def456ghi789']);
+    
+    // Verify second prompt with empty files
+    const secondPrompt = transformedPathway.prompt[1];
+    t.is(secondPrompt.name, 'Summarize Text');
+    t.falsy(secondPrompt.fileHashes); // Empty array results in no fileHashes property
+    
+    // Verify third prompt without files property
+    const thirdPrompt = transformedPathway.prompt[2];
+    t.is(thirdPrompt.name, 'Simple Task');
+    t.falsy(thirdPrompt.fileHashes);
+    
+    // Verify pathway-level file hashes collection
+    t.truthy(transformedPathway.fileHashes);
+    t.deepEqual(transformedPathway.fileHashes, ['abc123def456', 'def456ghi789']);
+});
+
+test('pathwayManager handles legacy string prompts correctly', async t => {
+    const pathwayManager = new PathwayManager(mockConfig, mockBasePathway);
+    
+    // Replace storage with mock
+    pathwayManager.storage = new MockStorageStrategy();
+    
+    // Test legacy string prompts
+    const legacyPathway = {
+        prompt: [
+            'Please analyze the data',
+            'Summarize the findings'
+        ],
+        systemPrompt: 'You are a helpful assistant'
+    };
+    
+    // Test transformPrompts method
+    const transformedPathway = await pathwayManager.transformPrompts(legacyPathway);
+    
+    // Verify the transformed pathway structure
+    t.truthy(transformedPathway);
+    t.true(Array.isArray(transformedPathway.prompt));
+    t.is(transformedPathway.prompt.length, 2);
+    
+    // Verify prompts don't have file hashes
+    transformedPathway.prompt.forEach(prompt => {
+        t.falsy(prompt.fileHashes);
+    });
+    
+    // Verify no pathway-level file hashes
+    t.falsy(transformedPathway.fileHashes);
+});
+
+test('pathwayManager removes duplicate file hashes at pathway level', async t => {
+    const pathwayManager = new PathwayManager(mockConfig, mockBasePathway);
+    
+    // Replace storage with mock
+    pathwayManager.storage = new MockStorageStrategy();
+    
+    // Test prompts with duplicate file hashes
+    const pathwayWithDuplicateFiles = {
+        prompt: [
+            {
+                name: 'First Task',
+                prompt: 'Analyze document 1',
+                files: ['abc123def456', 'def456ghi789']
+            },
+            {
+                name: 'Second Task', 
+                prompt: 'Analyze document 2',
+                files: ['abc123def456', 'ghi789jkl012'] // abc123def456 is duplicate
+            }
+        ],
+        systemPrompt: 'You are a helpful assistant'
+    };
+    
+    // Test transformPrompts method
+    const transformedPathway = await pathwayManager.transformPrompts(pathwayWithDuplicateFiles);
+    
+    // Verify pathway-level file hashes are deduplicated
+    t.truthy(transformedPathway.fileHashes);
+    t.deepEqual(transformedPathway.fileHashes, ['abc123def456', 'def456ghi789', 'ghi789jkl012']);
+    t.is(transformedPathway.fileHashes.length, 3); // Should not have duplicates
+});
+
+test('pathwayManager handles null and undefined files gracefully', async t => {
+    const pathwayManager = new PathwayManager(mockConfig, mockBasePathway);
+    
+    // Replace storage with mock
+    pathwayManager.storage = new MockStorageStrategy();
+    
+    // Test prompts with null/undefined files
+    const pathwayWithNullFiles = {
+        prompt: [
+            {
+                name: 'Task with null files',
+                prompt: 'Do something', 
+                files: null
+            },
+            {
+                name: 'Task with undefined files',
+                prompt: 'Do something else'
+                // files property is undefined
+            }
+        ],
+        systemPrompt: 'You are a helpful assistant'
+    };
+    
+    // Test transformPrompts method
+    const transformedPathway = await pathwayManager.transformPrompts(pathwayWithNullFiles);
+    
+    // Verify the transformation handles null/undefined gracefully
+    t.truthy(transformedPathway);
+    t.true(Array.isArray(transformedPathway.prompt));
+    
+    // Both prompts should have empty or undefined fileHashes
+    transformedPathway.prompt.forEach(prompt => {
+        t.true(!prompt.fileHashes || prompt.fileHashes.length === 0);
+    });
+    
+    // No pathway-level file hashes should be set
+    t.falsy(transformedPathway.fileHashes);
+});
+
+test('pathwayManager _createPromptObject handles files correctly', t => {
+    const pathwayManager = new PathwayManager(mockConfig, mockBasePathway);
+    
+    // Test with object prompt containing files
+    const promptWithFiles = {
+        name: 'Test Prompt',
+        prompt: 'Analyze this document',
+        files: ['file1hash', 'file2hash']
+    };
+    
+    const createdPrompt = pathwayManager._createPromptObject(promptWithFiles, 'System prompt');
+    
+    t.is(createdPrompt.name, 'Test Prompt');
+    t.truthy(createdPrompt.fileHashes);
+    t.deepEqual(createdPrompt.fileHashes, ['file1hash', 'file2hash']);
+    
+    // Test with string prompt (no files)
+    const stringPrompt = 'Simple text prompt';
+    const createdStringPrompt = pathwayManager._createPromptObject(stringPrompt, 'System prompt', 'Default Name');
+    
+    t.is(createdStringPrompt.name, 'Default Name');
+    t.falsy(createdStringPrompt.fileHashes);
+    
+    // Test with object prompt without files
+    const promptWithoutFiles = {
+        name: 'No Files Prompt',
+        prompt: 'Simple task'
+    };
+    
+    const createdPromptNoFiles = pathwayManager._createPromptObject(promptWithoutFiles, 'System prompt');
+    
+    t.is(createdPromptNoFiles.name, 'No Files Prompt');
+    t.falsy(createdPromptNoFiles.fileHashes);
+});