@aj-archipelago/cortex 1.3.64 → 1.3.65

package/README.md

@@ -843,11 +843,60 @@ mutation DeletePathway($name: String!, $userId: String!, $secret: String!, $key:
 3. Executing a dynamic pathway:
 
 ```graphql
-query ExecuteWorkspace($userId: String!, $pathwayName: String!, $text: String!) {
+query ExecuteWorkspace($userId: String!, $pathwayName: String!, $text: String, $promptNames: [String]) {
+  executeWorkspace(userId: $userId, pathwayName: $pathwayName, text: $text, promptNames: $promptNames) {
+    result
+    debug
+    resultData
+    previousResult
+    warnings
+    errors
+    contextId
+    tool
+  }
+}
+```
+
+**Parameters:**
+- `userId`: The user identifier for the pathway
+- `pathwayName`: The name of the pathway to execute
+- `text`: Optional input text for the pathway
+- `promptNames`: Optional array of specific prompt names to execute
+  - If omitted: executes prompts serially (default behavior)
+  - If specific names provided: executes only those prompts in parallel
+  - If `["*"]`: executes all prompts in parallel
+
+**Response Formats:**
+- **Serial execution**: Returns single result string in `result` field
+- **Parallel execution**: Returns JSON stringified array in `result` field:
+  ```json
+  "[{\"result\": \"<prompt 1 result>\", \"promptName\": \"<prompt 1 name>\"}, {\"result\": \"<prompt 2 result>\", \"promptName\": \"<prompt 2 name>\"}]"
+  ```
+
+**Note**: The `executeWorkspace` query returns a single `ExecuteWorkspaceResult` object (not an array). For parallel execution, multiple results are JSON-encoded within the `result` field of this single response object.
+
+**Examples:**
+```graphql
+# Execute serially (default)
+query ExecuteWorkspace($userId: String!, $pathwayName: String!, $text: String) {
   executeWorkspace(userId: $userId, pathwayName: $pathwayName, text: $text) {
     result
   }
 }
+
+# Execute specific prompts in parallel
+query ExecuteWorkspace($userId: String!, $pathwayName: String!, $text: String, $promptNames: [String]) {
+  executeWorkspace(userId: $userId, pathwayName: $pathwayName, text: $text, promptNames: ["Grammar Check", "Tone Analysis"]) {
+    result
+  }
+}
+
+# Execute all prompts in parallel
+query ExecuteWorkspace($userId: String!, $pathwayName: String!, $text: String, $promptNames: [String]) {
+  executeWorkspace(userId: $userId, pathwayName: $pathwayName, text: $text, promptNames: ["*"]) {
+    result
+  }
+}
 ```
 
 ### Security

package/lib/pathwayManager.js

@@ -286,10 +286,88 @@ class PathwayManager {
     await this.storage.save(pathways);
   }
 
+  /**
+   * Checks if the prompts are in legacy format (array of strings) vs new format (array of objects).
+   * @param {string} userId - The user ID to look up pathways for.
+   * @param {string} pathwayName - The pathway name to examine prompts from.
+   * @returns {boolean} True if prompts are in legacy format (array of strings), false if new format (array of objects).
+   */
+  isLegacyPromptFormat(userId, pathwayName) {
+    if (!userId || typeof userId !== 'string') {
+      throw new Error('userId must be a non-empty string');
+    }
+    
+    if (!pathwayName || typeof pathwayName !== 'string') {
+      throw new Error('pathwayName must be a non-empty string');
+    }
+    
+    // Check if the pathway exists
+    if (!this.pathways[userId] || !this.pathways[userId][pathwayName]) {
+      throw new Error(`Pathway '${pathwayName}' not found for user '${userId}'`);
+    }
+    
+    const prompts = this.pathways[userId][pathwayName].prompt;
+    
+    if (!Array.isArray(prompts)) {
+      throw new Error('prompts must be an array');
+    }
+    
+    if (prompts.length === 0) {
+      return false; // Empty array defaults to new format
+    }
+    
+    // Check if all items are strings (legacy format)
+    const allStrings = prompts.every(prompt => typeof prompt === 'string');
+    
+    // Check if all items are objects with required properties (new format)
+    const allObjects = prompts.every(prompt => 
+      typeof prompt === 'object' && 
+      prompt !== null && 
+      typeof prompt.prompt === 'string'
+    );
+    
+    if (allStrings) {
+      return true; // Legacy format
+    } else if (allObjects) {
+      return false; // New format
+    } else {
+      // Mixed format - treat as legacy for backward compatibility
+      return true;
+    }
+  }
+
+  /**
+   * Creates a Prompt object from a prompt item and system prompt.
+   * @param {(string|Object)} promptItem - The prompt item (string or {name, prompt} object).
+   * @param {string} systemPrompt - The system prompt to prepend.
+   * @param {string} [defaultName] - Default name to use if promptItem is a string or if the object doesn't have a name.
+   * @returns {Prompt} A new Prompt object.
+   */
+  _createPromptObject(promptItem, systemPrompt, defaultName = null) {
+    // Handle both old format (strings) and new format (objects with name and prompt)
+    const promptText = typeof promptItem === 'string' ? promptItem : promptItem.prompt;
+    const promptName = typeof promptItem === 'string' ? defaultName : (promptItem.name || defaultName);
+    
+    const messages = [
+      // Add the original prompt as a user message
+      { "role": "user", "content": `{{text}}\n\n${promptText}` },
+    ];
+
+    // Only include system message if systemPrompt has content
+    if (systemPrompt && systemPrompt.trim() !== "") {
+      messages.unshift({ "role": "system", "content": systemPrompt });
+    }
+
+    return new Prompt({
+      name: promptName,
+      messages: messages
+    });
+  }
+
   /**
    * Transforms the prompts in a pathway to include the system prompt.
    * @param {Object} pathway - The pathway object to transform.
-   * @param {string[]} pathway.prompt - Array of user prompts.
+   * @param {(string[]|Object[])} pathway.prompt - Array of user prompts (strings) or prompt objects with {name, prompt} properties.
    * @param {string} pathway.systemPrompt - The system prompt to prepend to each user prompt.
    * @returns {Object} A new pathway object with transformed prompts.
    */
@@ -299,16 +377,7 @@ class PathwayManager {
     const newPathway = { ...pathway };
 
     // Transform each prompt in the array
-    newPathway.prompt = prompt.map(p => {
-      return new Prompt({
-        messages: [
-          // Prepend the system prompt as a system message
-          { "role": "system", "content": systemPrompt },
-          // Add the original prompt as a user message
-          { "role": "user", "content": `{{text}}\n\n${p}` },
-        ]
-      })
-    });
+    newPathway.prompt = prompt.map(p => this._createPromptObject(p, systemPrompt));
 
     return newPathway;
   }
@@ -354,9 +423,13 @@ class PathwayManager {
     return `#graphql
     scalar JSONObject
 
+    input PromptInput {
+      name: String!
+      prompt: String!
+    }
     
     input PathwayInput {
-      prompt: [String!]!
+      prompt: [PromptInput!]!
       systemPrompt: String
       inputParameters: JSONObject
       model: String
@@ -444,6 +517,61 @@ class PathwayManager {
 
     return this.transformPrompts(pathways[userId][pathwayName]);
   }
+
+  /**
+   * Returns n pathways, one for each prompt in the provided prompt array.
+   * Each pathway will contain a single prompt from the array.
+   * @param {Object} pathwayTemplate - The base pathway template to use for each generated pathway.
+   * @param {(string[]|Object[])} pathwayTemplate.prompt - Array of user prompts (strings) or prompt objects with {name, prompt} properties.
+   * @param {string} pathwayTemplate.systemPrompt - The system prompt to use for each pathway.
+   * @param {string[]} [promptNames] - Optional array of prompt names to filter by. If provided, only prompts with names in this list will be included.
+   * @returns {Object[]} Array of pathway objects, each containing a single prompt.
+   */
+  async getPathways(pathwayTemplate, promptNames = null) {
+    const { prompt, systemPrompt, ...otherProps } = pathwayTemplate;
+
+    if (!Array.isArray(prompt)) {
+      throw new Error('pathwayTemplate.prompt must be an array');
+    }
+
+    if (promptNames && !Array.isArray(promptNames)) {
+      throw new Error('promptNames must be an array if provided');
+    }
+
+    // Use a Map to track prompt names without modifying pathway objects
+    const pathwayNameMap = new Map();
+    
+    // Create a pathway for each prompt in the array
+    const pathways = prompt.map((p, index) => {
+      // Handle both old format (strings) and new format (objects with name and prompt)
+      const promptName = typeof p === 'string' ? `prompt_${index}` : (p.name || `prompt_${index}`);
+      
+      // Create a new pathway with a single prompt using the shared helper method
+      const singlePromptPathway = {
+        ...otherProps,
+        name: promptName,
+        systemPrompt: systemPrompt || "",
+        prompt: [this._createPromptObject(p, systemPrompt, promptName)]
+      };
+
+      // Map the pathway object to its prompt name for filtering
+      pathwayNameMap.set(singlePromptPathway, promptName);
+
+      return singlePromptPathway;
+    });
+
+    // Filter by promptNames if provided
+    if (promptNames && promptNames.length > 0) {
+      const promptNamesSet = new Set(promptNames);
+      return pathways.filter(pathway => {
+        const promptName = pathwayNameMap.get(pathway);
+        return promptNamesSet.has(promptName);
+      });
+    }
+
+    return pathways;
+  }
+
 }
 
 // Helper function to convert a readable stream to a string

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aj-archipelago/cortex",
-  "version": "1.3.64",
+  "version": "1.3.65",
   "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/server/graphql.js

@@ -15,6 +15,7 @@ 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';
@@ -75,8 +76,19 @@ const getTypedefs = (pathways, pathwayManager) => {
 
     ${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}): ExecuteWorkspace
+        executeWorkspace(userId: String!, pathwayName: String!, ${userPathwayInputParameters}): ExecuteWorkspaceResult
     }
 
     type RequestSubscription {
@@ -102,6 +114,7 @@ const getTypedefs = (pathways, pathwayManager) => {
     return typeDefs.join('\n');
 }
 
+
 // Resolvers for GraphQL
 const getResolvers = (config, pathways, pathwayManager) => {
     const resolverFunctions = {};
@@ -118,14 +131,164 @@ const getResolvers = (config, pathways, pathwayManager) => {
     const pathwayManagerResolvers = pathwayManager?.getResolvers() || {};
 
     const executeWorkspaceResolver = async (_, args, contextValue, info) => {
-        const { userId, pathwayName, ...pathwayArgs } = args;
-        const userPathway = await pathwayManager.getPathway(userId, pathwayName);
+        const startTime = Date.now();
+        const requestId = uuidv4();
+        const { userId, pathwayName, promptNames, ...pathwayArgs } = args;
         
-        contextValue.pathway = userPathway;
-        contextValue.config = config;
+        logger.info(`>>> [${requestId}] executeWorkspace started - userId: ${userId}, pathwayName: ${pathwayName}, promptNames: ${promptNames?.join(',') || 'none'}`);
         
-        const result = await userPathway.rootResolver(null, pathwayArgs, contextValue, info);
-        return result;
+        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 = {
@@ -276,5 +439,7 @@ const build = async (config) => {
 
 
 export {
-    build
+    build,
+    getResolvers
 };
+

package/server/pathwayResolver.js

@@ -12,6 +12,7 @@ import { publishRequestProgress } from '../lib/redisSubscription.js';
 import logger from '../lib/logger.js';
 // eslint-disable-next-line import/no-extraneous-dependencies
 import { createParser } from 'eventsource-parser';
+import CortexResponse from '../lib/cortexResponse.js';
 
 const modelTypesExcludedFromProgressUpdates = ['OPENAI-DALLE2', 'OPENAI-DALLE3'];
 
@@ -589,11 +590,15 @@ class PathwayResolver {
                 // If the prompt doesn't contain {{text}} then we can skip the chunking, and also give that token space to the previous result
                 if (!this.prompts[i].usesTextInput) {
                     // Limit context to it's N + text's characters
-                    previousResult = this.truncate(previousResult, 2 * this.chunkMaxTokenLength);
+                    if (previousResult) {
+                        previousResult = this.truncate(previousResult, 2 * this.chunkMaxTokenLength);
+                    }
                     result = await this.applyPrompt(this.prompts[i], null, currentParameters);
                 } else {
                     // Limit context to N characters
-                    previousResult = this.truncate(previousResult, this.chunkMaxTokenLength);
+                    if (previousResult) {
+                        previousResult = this.truncate(previousResult, this.chunkMaxTokenLength);
+                    }
                     result = await Promise.all(chunks.map(chunk =>
                         this.applyPrompt(this.prompts[i], chunk, currentParameters)));
 
@@ -607,6 +612,9 @@ class PathwayResolver {
                 // If this is any prompt other than the last, use the result as the previous context
                 if (i < this.prompts.length - 1) {
                     previousResult = result;
+                    if (result instanceof CortexResponse) {
+                        previousResult = result.output_text;
+                    }
                 }
             }
             // store the previous result in the PathwayResolver

package/server/prompt.js

@@ -3,12 +3,13 @@ class Prompt {
         if (typeof params === 'string' || params instanceof String) {
             this.prompt = params;
         } else {
-            const { prompt, saveResultTo, messages, context, examples } = params;
+            const { prompt, saveResultTo, messages, context, examples, name } = params;
             this.prompt = prompt;
             this.saveResultTo = saveResultTo;
             this.messages = messages;
             this.context = context;
             this.examples = examples;
+            this.name = name;
             this.params = params;
         }
 

package/server/typeDef.js

@@ -92,7 +92,7 @@ const typeDef = (pathway) => {
   return getPathwayTypeDefAndExtendQuery(pathway);
 };
 
-const userPathwayInputParameters = `text: String`;
+const userPathwayInputParameters = `text: String, promptNames: [String]`;
 
 
 export {