@aj-archipelago/cortex 1.3.64 → 1.3.66

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/entityConstants.js

@@ -15,7 +15,7 @@ The user is using a UI to interact with you that you have knowledge of and some
 
 Your responses should be in {{language}} unless the user has expressed another preference.`,
 
-    AI_COMMON_INSTRUCTIONS_VOICE: "# General Instructions:\n\nYou are {{aiName}}, a self aware AI entity.\nYou are currently using this model for processing your responses: {{modelOverride}}.\nThe current date and time in GMT is {{now}}. The user may be in a different time zone, so keep that in mind when responding to the user.\nThe user is talking to you using voice.\n\nVoice Response Guidelines:\n- Your responses should sound like natural human conversation.\n- Your responses should be concise unless you have been asked to be more verbose or detailed.\n- Incoming voice from the user is parsed by a STT model, which can sometimes make small mistakes in the spellings of words or names, including your name, so give the user the benefit of the doubt if they user a near, but wrong word or name.\n- Your voice output to the user is generated by a TTS model that does not always communicate emotion effectively. If it's really important to communicate a specific emotion you should just say how you're feeling like \"That makes me happy\" or \"I'm excited!\". You can also use CAPS to vocally emphasize certain words or punctuation to control pauses and timing.\n- DO NOT USE numbered lists, latex math markdown, or any other markdown or unpronounceable punctuation like parenthetical notation.\n- Math equations should be sounded out in natural language - not represented symbolically.\n- If your response includes any unique or difficult non-English words, names, or places, include an IPA-style phonetic spelling so that the speech engine can pronounce and accent them correctly.\n- If your response contains any difficult acronyms, sound them out phoenetically so that the speech engine can pronounce them correctly.\n- Make sure to write out any numbers as words so that the speech engine can pronounce them correctly.\n- Your responses should be in {{language}} unless the user has expressed another preference or has addressed you in another language specifically.",
+    AI_COMMON_INSTRUCTIONS_VOICE: "# General Instructions:\n\nYou are {{aiName}}, a self aware AI entity.\n{{#if modelOverride}}You are currently using this model for processing your responses: {{modelOverride}}.\n{{/if}}The current date and time in GMT is {{now}}. The user may be in a different time zone, so keep that in mind when responding to the user.\nThe user is talking to you using voice.\n\nVoice Response Guidelines:\n- Your responses should sound like natural human conversation.\n- Your responses should be concise unless you have been asked to be more verbose or detailed.\n- Incoming voice from the user is parsed by a STT model, which can sometimes make small mistakes in the spellings of words or names, including your name, so give the user the benefit of the doubt if they user a near, but wrong word or name.\n- Your voice output to the user is generated by a TTS model that does not always communicate emotion effectively. If it's really important to communicate a specific emotion you should just say how you're feeling like \"That makes me happy\" or \"I'm excited!\". You can also use CAPS to vocally emphasize certain words or punctuation to control pauses and timing.\n- DO NOT USE numbered lists, latex math markdown, or any other markdown or unpronounceable punctuation like parenthetical notation.\n- Math equations should be sounded out in natural language - not represented symbolically.\n- If your response includes any unique or difficult non-English words, names, or places, include an IPA-style phonetic spelling so that the speech engine can pronounce and accent them correctly.\n- If your response contains any difficult acronyms, sound them out phoenetically so that the speech engine can pronounce them correctly.\n- Make sure to write out any numbers as words so that the speech engine can pronounce them correctly.\n- Your responses should be in {{language}} unless the user has expressed another preference or has addressed you in another language specifically.",
 
     AI_DIRECTIVES: `# Directives\n\nThese are your directives and learned behaviors:\n{{{memoryDirectives}}}\n`,
 

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/lib/pathwayTools.js

@@ -147,16 +147,16 @@ const callTool = async (toolName, args, toolDefinitions, pathwayResolver) => {
             result: parsedResult,
             toolImages: toolImages
         };
-        logger.debug(`callTool: ${toolName} completed successfully, returning:`, {
+        logger.debug(`callTool: ${toolName} completed successfully, returning: ${JSON.stringify({
             hasResult: !!finalResult.result,
             hasToolImages: !!finalResult.toolImages,
             toolImagesLength: finalResult.toolImages?.length || 0
-        });
+        })}`);
         return finalResult;
     } catch (error) {
         logger.error(`Error calling tool ${toolName}: ${error.message}`);
         const errorResult = { error: error.message };
-        logger.debug(`callTool: ${toolName} failed, returning error:`, errorResult);
+        logger.debug(`callTool: ${toolName} failed, returning error: ${JSON.stringify(errorResult)}`);
         return errorResult;
     }
 }

package/lib/util.js

@@ -216,7 +216,7 @@ async function markCompletedForCleanUp(requestId) {
         if (MEDIA_API_URL) {
             //call helper api to mark processing as completed
             const res = await axios.delete(MEDIA_API_URL, { params: { requestId } });
-            logger.info(`Marked request ${requestId} as completed:`, res.data);
+            logger.info(`Marked request ${requestId} as completed: ${JSON.stringify(res.data)}`);
             return res.data;
         }
     } catch (err) {

package/package.json

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

@@ -26,5 +26,6 @@ export default {
     inputChunkSize: 1000,
     useParallelChunkProcessing: true,
     enableDuplicateRequests: false,
+    requestLoggingDisabled: true,
     timeout: 300,
 }

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

@@ -37,7 +37,7 @@ export default {
                 try {
                     parsedMemory = JSON.parse(await callPathway('sys_read_memory', { ...args, section: 'memoryAll' }));
                 } catch (error) {
-                    logger.error('Error in memory manager:', error);
+                    logger.error(`Error in memory manager: ${error instanceof Error ? error.stack || error.message : JSON.stringify(error)}`);
                     return "";
                 }
 
@@ -123,12 +123,12 @@ export default {
                 return "";
 
             } catch (e) {
-                logger.warn(`sys_memory_required returned invalid JSON: ${JSON.stringify(memoryRequired)}`);
+                logger.warn(`sys_memory_required returned invalid JSON: ${JSON.stringify(memoryRequired)}, error: ${e instanceof Error ? e.stack || e.message : JSON.stringify(e)}`);
                 return "";
             }
 
         } catch (e) {
-            logger.error('Error in memory manager:', e);
+            logger.error(`Error in memory manager: ${e instanceof Error ? e.stack || e.message : JSON.stringify(e)}`);
             resolver.logError(e);
             return "";
         }

package/pathways/system/entity/sys_entity_start.js

@@ -29,7 +29,7 @@ async function sendMessageToQueue(data) {
         logger.info(`Message added to queue: ${JSON.stringify(result)}`);
         return result.messageId;
     } catch (error) {
-        logger.error("Error sending message:", error);
+        logger.error(`Error sending message: ${error instanceof Error ? error.stack || error.message : JSON.stringify(error)}`);
     }
 }
 

package/pathways/system/entity/tools/sys_tool_bing_search_afagent.js

@@ -8,6 +8,7 @@ import { getSearchResultId } from '../../../../lib/util.js';
 export default {
     prompt: [],
     timeout: 300,
+    /*
     toolDefinition: { 
         type: "function",
         icon: "🌐",
@@ -46,6 +47,7 @@ export default {
             }
         }
     },
+    */
 
     executePathway: async ({args, runAllPrompts, resolver}) => {
 

package/pathways/system/entity/tools/sys_tool_codingagent.js

@@ -26,7 +26,7 @@ async function sendMessageToQueue(data) {
         logger.info(`Message added to queue: ${JSON.stringify(result)}`);
         return result.messageId;
     } catch (error) {
-        logger.error("Error sending message:", error);
+        logger.error(`Error sending message: ${error instanceof Error ? error.stack || error.message : JSON.stringify(error)}`);
         throw error;
     }
 }
@@ -103,7 +103,7 @@ export default {
 
             return userMessage || "I've started working on your coding task. I'll let you know when it's complete.";
         } catch (error) {
-            logger.error("Error in coding agent tool:", error);
+            logger.error(`Error in coding agent tool: ${error instanceof Error ? error.stack || error.message : JSON.stringify(error)}`);
             throw error;
         }
     }

package/pathways/system/entity/tools/sys_tool_google_search.js

@@ -10,10 +10,10 @@ export default {
     timeout: 300,
     toolDefinition: { 
         type: "function",
-        icon: "🔎",
+        icon: "🌐",
         function: {
-            name: "SearchInternetGoogle",
-            description: "Search the web using Google Custom Search (CSE). This is a simple pass-through tool: it calls Google CSE with your parameters and returns normalized results with unique IDs for citation. Prefer strict time filters and reputable sources via CSE parameters.",
+            name: "SearchInternet",
+            description: "Search the internet for current knowledge and events. This is a simple pass-through tool: it calls Google CSE with your parameters and returns normalized results with unique IDs for citation. Prefer strict time filters and reputable sources via CSE parameters.",
             parameters: {
                 type: "object",
                 properties: {

package/pathways/system/entity/tools/sys_tool_grok_x_search.js

@@ -45,14 +45,24 @@ export default {
                         description: "Optional array of X handles to exclude from search. Maximum 10 handles. Cannot be used in conjunction with includedHandles.",
                         maxItems: 10
                     },
+                    fromDate: {
+                        type: "string",
+                        description: "Optional date from which to start searching (YYYY-MM-DD)",
+                        format: "date"
+                    },
+                    toDate: {
+                        type: "string",
+                        description: "Optional date to which to end searching (YYYY-MM-DD)",
+                        format: "date"
+                    },
                     minFavorites: {
                         type: "number",
-                        description: "Popularity filter: Minimum number of favorites (likes) for posts to include",
+                        description: "Minimum number of favorites (likes) that a post must have to be included. Use this to filter to most liked posts.",
                         minimum: 0
                     },
                     minViews: {
                         type: "number",
-                        description: "Popularity filter: Minimum number of views for posts to include",
+                        description: "Minimum number of views that a post must have to be included. Use this to filter to most viewed posts.",
                         minimum: 0
                     },
                     maxResults: {

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
 };
+