@aj-archipelago/cortex 1.0.9 → 1.0.11

package/server/pathwayResolver.js

@@ -25,7 +25,7 @@ class PathwayResolver {
             args?.model,
             pathway.inputParameters?.model,
             config.get('defaultModelName')
-            ].find(modelName => modelName && config.get('models').hasOwnProperty(modelName));
+            ].find(modelName => modelName && Object.prototype.hasOwnProperty.call(config.get('models'), modelName));
         this.model = config.get('models')[this.modelName];
 
         if (!this.model) {
@@ -63,57 +63,118 @@ class PathwayResolver {
         this.pathwayPrompt = pathway.prompt;
     }
 
+    // This code handles async and streaming responses.  In either case, we use
+    // the graphql subscription to send progress updates to the client.  Most of 
+    // the time the client will be an external client, but it could also be the
+    // Cortex REST api code.
     async asyncResolve(args) {
-        const responseData = await this.promptAndParse(args);
+        const MAX_RETRY_COUNT = 3;
+        let attempt = 0;
+        let streamErrorOccurred = false;
+
+        while (attempt < MAX_RETRY_COUNT) {
+            const responseData = await this.executePathway(args);
+
+            if (args.async || typeof responseData === 'string') {
+                const { completedCount, totalCount } = requestState[this.requestId];
+                requestState[this.requestId].data = responseData;
+                pubsub.publish('REQUEST_PROGRESS', {
+                    requestProgress: {
+                        requestId: this.requestId,
+                        progress: completedCount / totalCount,
+                        data: JSON.stringify(responseData),
+                    }
+                });
+            } else {
+                try {
+                    const incomingMessage = responseData;
 
-        // Either we're dealing with an async request or a stream
-        if(args.async || typeof responseData === 'string') {
-            const { completedCount, totalCount } = requestState[this.requestId];
-            requestState[this.requestId].data = responseData;
-            pubsub.publish('REQUEST_PROGRESS', {
-                requestProgress: {
-                    requestId: this.requestId,
-                    progress: completedCount / totalCount,
-                    data: JSON.stringify(responseData),
-                }
-            });
-        } else { // stream
-            try {
-                const incomingMessage = Array.isArray(responseData) && responseData.length > 0 ? responseData[0] : responseData;
-                incomingMessage.on('data', data => {
-                    const events = data.toString().split('\n');
-            
-                    events.forEach(event => {
-                        if (event.trim() === '') return; // Skip empty lines
-            
-                        const message = event.replace(/^data: /, '');
-                        
-                        //console.log(`====================================`);
-                        //console.log(`STREAM EVENT: ${event}`);
-                        //console.log(`MESSAGE: ${message}`);
-            
-                        const requestProgress = {
-                            requestId: this.requestId,
-                            data: message,
-                        }
-            
-                        if (message.trim() === '[DONE]') {
-                            requestProgress.progress = 1;
-                        }
-            
+                    const processData = (data) => {
                         try {
-                            pubsub.publish('REQUEST_PROGRESS', {
-                                requestProgress: requestProgress
-                            });
+                            //console.log(`\n\nReceived stream data for requestId ${this.requestId}`, data.toString());
+                            let events = data.toString().split('\n');
+                            
+                            //events = "data: {\"id\":\"chatcmpl-20bf1895-2fa7-4ef9-abfe-4d142aba5817\",\"object\":\"chat.completion.chunk\",\"created\":1689303423723,\"model\":\"gpt-4\",\"choices\":[{\"delta\":{\"role\":\"assistant\",\"content\":{\"error\":{\"message\":\"The server had an error while processing your request. Sorry about that!\",\"type\":\"server_error\",\"param\":null,\"code\":null}}},\"finish_reason\":null}]}\n\n".split("\n");
+
+                            for (let event of events) {
+                                if (streamErrorOccurred) break;
+                                
+                                // skip empty events
+                                if (!(event.trim() === '')) {
+                                    //console.log(`Processing stream event for requestId ${this.requestId}`, event);
+
+                                    let message = event.replace(/^data: /, '');
+
+                                    const requestProgress = {
+                                        requestId: this.requestId,
+                                        data: message,
+                                    }
+
+                                    // check for end of stream or in-stream errors
+                                    if (message.trim() === '[DONE]') {
+                                        requestProgress.progress = 1;
+                                    } else {
+                                        let parsedMessage;
+                                        try {
+                                            parsedMessage = JSON.parse(message);
+                                        } catch (error) {
+                                            console.error('Could not JSON parse stream message', message, error);
+                                            return;
+                                        }
+
+                                        const streamError = parsedMessage.error || parsedMessage?.choices?.[0]?.delta?.content?.error || parsedMessage?.choices?.[0]?.text?.error;
+                                        if (streamError) {
+                                            streamErrorOccurred = true;
+                                            console.error(`Stream error: ${streamError.message}`);
+                                            incomingMessage.off('data', processData); // Stop listening to 'data'
+                                            return;
+                                        }
+                                    }
+
+                                    try {
+                                        //console.log(`Publishing stream message to requestId ${this.requestId}`, message);
+                                        pubsub.publish('REQUEST_PROGRESS', {
+                                            requestProgress: requestProgress
+                                        });
+                                    } catch (error) {
+                                        console.error('Could not publish the stream message', message, error);
+                                    }
+                                }
+                            }
                         } catch (error) {
-                            console.error('Could not JSON parse stream message', message, error);
+                            console.error('Could not process stream data', error);
                         }
-                    });
-                });
-            } catch (error) {
-                console.error('Could not subscribe to stream', error);
+                    };
+
+                    if (incomingMessage) {
+                        await new Promise((resolve, reject) => {
+                            incomingMessage.on('data', processData);
+                            incomingMessage.on('end', resolve);
+                            incomingMessage.on('error', reject);
+                        });
+                    }
+
+                } catch (error) {
+                    console.error('Could not subscribe to stream', error);
+                }
+            }
+
+            if (streamErrorOccurred) {
+                attempt++;
+                console.error(`Stream attempt ${attempt} failed. Retrying...`);
+                streamErrorOccurred = false; // Reset the flag for the next attempt
+            } else {
+                return;
             }
         }
+        // if all retries failed, publish the stream end message
+        pubsub.publish('REQUEST_PROGRESS', {
+            requestProgress: {
+                requestId: this.requestId,
+                progress: 1,
+                data: '[DONE]',
+            }
+        });
     }
 
     async resolve(args) {
@@ -127,6 +188,15 @@ class PathwayResolver {
         }
         else {
             // Syncronously process the request
+            return await this.executePathway(args);
+        }
+    }
+
+    async executePathway(args) {
+        if (this.pathway.executePathway && typeof this.pathway.executePathway === 'function') {
+            return await this.pathway.executePathway({ args, runAllPrompts: this.promptAndParse.bind(this) });
+        }
+        else {
             return await this.promptAndParse(args);
         }
     }
@@ -167,7 +237,7 @@ class PathwayResolver {
         } else {
             chunkTokenLength = this.chunkMaxTokenLength;
         }
-        const encoded = encode(text);
+        const encoded = text ? encode(text) : [];
         if (!this.useInputChunking || encoded.length <= chunkTokenLength) { // no chunking, return as is
             if (encoded.length > 0 && encoded.length >= chunkTokenLength) {
                 const warnText = `Truncating long input text. Text length: ${text.length}`;
@@ -275,8 +345,11 @@ class PathwayResolver {
                     previousResult = this.truncate(previousResult, this.chunkMaxTokenLength);
                     result = await Promise.all(chunks.map(chunk =>
                         this.applyPrompt(this.prompts[i], chunk, currentParameters)));
-                    if (!currentParameters.stream) {
-                        result = result.join("\n\n")
+
+                    if (result.length === 1) {
+                        result = result[0];
+                    } else if (!currentParameters.stream) {
+                        result = result.join("\n\n");
                     }
                 }
 

package/server/pathwayResponseParser.js

@@ -1,29 +1,25 @@
-import { parseNumberedList, parseNumberedObjectList, parseCommaSeparatedList } from './parser.js';
+import { parseNumberedList, parseNumberedObjectList, parseCommaSeparatedList, isCommaSeparatedList, isNumberedList } from './parser.js';
 
 class PathwayResponseParser {
     constructor(pathway) {
         this.pathway = pathway;
     }
 
-    isCommaSeparatedList(data) {
-        const commaSeparatedPattern = /^([^,\n]+,)+[^,\n]+$/;
-        return commaSeparatedPattern.test(data.trim());
-    }
-
     parse(data) {
         if (this.pathway.parser) {
             return this.pathway.parser(data);
         }
 
         if (this.pathway.list) {
-            if (this.isCommaSeparatedList(data)) {
-                return parseCommaSeparatedList(data);
-            } else {
+            if (isNumberedList(data)) {
                 if (this.pathway.format) {
                     return parseNumberedObjectList(data, this.pathway.format);
                 }
                 return parseNumberedList(data);
+            } else if (isCommaSeparatedList(data)) {
+                return parseCommaSeparatedList(data);
             }
+            return [data];
         }
 
         return data;

package/server/plugins/azureTranslatePlugin.js

@@ -26,7 +26,7 @@ class AzureTranslatePlugin extends ModelPlugin {
     // Execute the request to the Azure Translate API
     async execute(text, parameters, prompt, pathwayResolver) {
         const requestParameters = this.getRequestParameters(text, parameters, prompt);
-        const requestId = pathwayResolver?.requestId;
+        const { requestId, pathway} = pathwayResolver;
 
         const url = this.requestUrl(text);
 
@@ -34,7 +34,7 @@ class AzureTranslatePlugin extends ModelPlugin {
         const params = requestParameters.params;
         const headers = this.model.headers || {};
 
-        return this.executeRequest(url, data, params, headers, prompt, requestId);
+        return this.executeRequest(url, data, params, headers, prompt, requestId, pathway);
     }
     
     // Parse the response from the Azure Translate API
@@ -55,7 +55,7 @@ class AzureTranslatePlugin extends ModelPlugin {
         console.log(`\x1b[36m${modelInput}\x1b[0m`);
         console.log(`\x1b[34m> ${this.parseResponse(responseData)}\x1b[0m`);
     
-        prompt && prompt.debugInfo && (prompt.debugInfo += `${separator}${JSON.stringify(data)}`);
+        prompt && prompt.debugInfo && (prompt.debugInfo += `\n${JSON.stringify(data)}`);
     }
 }
 

package/server/plugins/cohereGeneratePlugin.js

@@ -0,0 +1,60 @@
+// CohereGeneratePlugin.js
+import ModelPlugin from './modelPlugin.js';
+
+class CohereGeneratePlugin extends ModelPlugin {
+    constructor(config, pathway, modelName, model) {
+        super(config, pathway, modelName, model);
+    }
+
+    // Set up parameters specific to the Cohere API
+    getRequestParameters(text, parameters, prompt) {
+        const { modelPromptText, tokenLength } = this.getCompiledPrompt(text, parameters, prompt);
+
+        // Define the model's max token length
+        const modelTargetTokenLength = this.getModelMaxTokenLength() * this.getPromptTokenRatio();
+    
+        // Check if the token length exceeds the model's max token length
+        if (tokenLength > modelTargetTokenLength) {
+            // Truncate the prompt text to fit within the token length
+            modelPromptText = modelPromptText.substring(0, modelTargetTokenLength);
+        }
+    
+        const requestParameters = {
+            model: "command",
+            prompt: modelPromptText,
+            max_tokens: this.getModelMaxReturnTokens(),
+            temperature: this.temperature ?? 0.7,
+            k: 0,
+            stop_sequences: parameters.stop_sequences || [],
+            return_likelihoods: parameters.return_likelihoods || "NONE"
+        };
+    
+        return requestParameters;
+    }
+
+    // Execute the request to the Cohere API
+    async execute(text, parameters, prompt, pathwayResolver) {
+        const url = this.requestUrl();
+        const requestParameters = this.getRequestParameters(text, parameters, prompt);
+        const { requestId, pathway} = pathwayResolver;
+
+        const data = { ...(this.model.params || {}), ...requestParameters };
+        const params = {};
+        const headers = { 
+            ...this.model.headers || {}
+        };
+        return this.executeRequest(url, data, params, headers, prompt, requestId, pathway);
+    }
+
+    // Parse the response from the Cohere API
+    parseResponse(data) {
+        const { generations } = data;
+        if (!generations || !generations.length) {
+            return data;
+        }
+        // Return the text of the first generation
+        return generations[0].text || null;
+    }
+}
+
+export default CohereGeneratePlugin;

package/server/plugins/cohereSummarizePlugin.js

@@ -0,0 +1,50 @@
+// CohereSummarizePlugin.js
+import ModelPlugin from './modelPlugin.js';
+
+class CohereSummarizePlugin extends ModelPlugin {
+    constructor(config, pathway, modelName, model) {
+        super(config, pathway, modelName, model);
+    }
+
+    // Set up parameters specific to the Cohere Summarize API
+    getRequestParameters(text, parameters, prompt) {
+        const { modelPromptText } = this.getCompiledPrompt(text, parameters, prompt);
+
+        const requestParameters = {
+            length: parameters.length || "medium",
+            format: parameters.format || "paragraph",
+            model: "summarize-xlarge",
+            extractiveness: parameters.extractiveness || "low",
+            temperature: this.temperature ?? 0.3,
+            text: modelPromptText
+        };
+    
+        return requestParameters;
+    }
+
+    // Execute the request to the Cohere Summarize API
+    async execute(text, parameters, prompt, pathwayResolver) {
+        const url = this.requestUrl();
+        const requestParameters = this.getRequestParameters(text, parameters, prompt);
+        const { requestId, pathway} = pathwayResolver;
+
+        const data = { ...(this.model.params || {}), ...requestParameters };
+        const params = {};
+        const headers = { 
+            ...this.model.headers || {}
+        };
+        return this.executeRequest(url, data, params, headers, prompt, requestId, pathway);
+    }
+
+    // Parse the response from the Cohere Summarize API
+    parseResponse(data) {
+        const { summary } = data;
+        if (!summary) {
+            return data;
+        }
+        // Return the summary
+        return summary;
+    }
+}
+
+export default CohereSummarizePlugin;

package/server/plugins/modelPlugin.js

@@ -22,11 +22,11 @@ class ModelPlugin {
 
         // Make all of the parameters defined on the pathway itself available to the prompt
         for (const [k, v] of Object.entries(pathway)) {
-            this.promptParameters[k] = v.default ?? v;
+            this.promptParameters[k] = v?.default ?? v;
         }
         if (pathway.inputParameters) {
             for (const [k, v] of Object.entries(pathway.inputParameters)) {
-                this.promptParameters[k] = v.default ?? v;
+                this.promptParameters[k] = v?.default ?? v;
             }
         }
 
@@ -121,7 +121,16 @@ class ModelPlugin {
 
     // compile the Prompt    
     getCompiledPrompt(text, parameters, prompt) {
-        const combinedParameters = { ...this.promptParameters, ...parameters };
+        
+        const mergeParameters = (promptParameters, parameters) => {
+            let result = { ...promptParameters };
+            for (let key in parameters) {
+                if (parameters[key] !== null) result[key] = parameters[key];
+            }
+            return result;
+        }
+
+        const combinedParameters = mergeParameters(this.promptParameters, parameters);
         const modelPrompt = this.getModelPrompt(prompt, parameters);
         const modelPromptText = modelPrompt.prompt ? HandleBars.compile(modelPrompt.prompt)({ ...combinedParameters, text }) : '';
         const modelPromptMessages = this.getModelPromptMessages(modelPrompt, combinedParameters, text);
@@ -197,24 +206,25 @@ class ModelPlugin {
     }
 
     // Default response parsing
-    parseResponse(data) { return data; };
+    parseResponse(data) { return data; }
 
     // Default simple logging
-    logRequestStart(url, data) {
+    logRequestStart(url, _data) {
         this.requestCount++;
+        this.lastRequestStartTime = new Date();
         const logMessage = `>>> [${this.requestId}: ${this.pathwayName}.${this.requestCount}] request`;
         const header = '>'.repeat(logMessage.length);
         console.log(`\n${header}\n${logMessage}`);
         console.log(`>>> Making API request to ${url}`);
-    };
+    }
 
     logAIRequestFinished() {
         const currentTime = new Date();
         const timeElapsed = (currentTime - this.lastRequestStartTime) / 1000;
-        const logMessage = `<<< [${this.requestId}: ${this.pathwayName}.${this.requestCount}] response - complete in ${timeElapsed}s - data:`;
+        const logMessage = `<<< [${this.requestId}: ${this.pathwayName}] response - complete in ${timeElapsed}s - data:`;
         const header = '<'.repeat(logMessage.length);
         console.log(`\n${header}\n${logMessage}\n`);
-    };
+    }
 
     logRequestData(data, responseData, prompt) {
         this.logAIRequestFinished(); 
@@ -226,21 +236,26 @@ class ModelPlugin {
     
         console.log(`\x1b[34m> ${this.parseResponse(responseData)}\x1b[0m`);
     
-        prompt && prompt.debugInfo && (prompt.debugInfo += `${separator}${JSON.stringify(data)}`);
+        prompt && prompt.debugInfo && (prompt.debugInfo += `\n${JSON.stringify(data)}`);
     }
     
-    async executeRequest(url, data, params, headers, prompt, requestId) {
-        this.aiRequestStartTime = new Date();
-        this.requestId = requestId;
-        this.logRequestStart(url, data);
-        const responseData = await request({ url, data, params, headers, cache: this.shouldCache }, this.modelName);
+    async executeRequest(url, data, params, headers, prompt, requestId, pathway) {
+        try {
+            this.aiRequestStartTime = new Date();
+            this.requestId = requestId;
+            this.logRequestStart(url, data);
+            const responseData = await request({ url, data, params, headers, cache: this.shouldCache }, this.modelName, this.requestId, pathway);
+            
+            if (responseData.error) {
+                throw new Error(`An error was returned from the server: ${JSON.stringify(responseData.error)}`);
+            }
         
-        if (responseData.error) {
-            throw new Error(`An error was returned from the server: ${JSON.stringify(responseData.error)}`);
+            this.logRequestData(data, responseData, prompt);
+            return this.parseResponse(responseData);
+        } catch (error) {
+            // Log the error and continue
+            console.error(error);
         }
-    
-        this.logRequestData(data, responseData, prompt);
-        return this.parseResponse(responseData);
     }
 
 }

package/server/plugins/openAiChatExtensionPlugin.js

@@ -0,0 +1,56 @@
+// OpenAIChatPlugin.js
+import OpenAIChatPlugin from './openAiChatPlugin.js';
+
+class OpenAIChatExtensionPlugin extends OpenAIChatPlugin {
+    constructor(config, pathway, modelName, model) {
+        super(config, pathway, modelName, model);
+        this.tool = '';
+    }
+
+    // Parse the response from the OpenAI Extension API
+    parseResponse(data) {
+        const { choices } = data;
+        if (!choices || !choices.length) {
+            return data;
+        }
+
+        // if we got a choices array back with more than one choice, return the whole array
+        if (choices.length > 1) {
+            return choices;
+        }
+
+        // otherwise, return the first choice messages based on role
+        const messageResult = [];
+        for(const message of choices[0].messages) {
+            if(message.role === "tool"){
+                this.tool = message.content;
+            }else{
+                messageResult.push(message.content);
+            }
+        }
+        return messageResult.join('\n\n') ?? null;
+    }
+
+    // Set up parameters specific to the OpenAI Chat API
+    getRequestParameters(text, parameters, prompt) {
+        const reqParams = super.getRequestParameters(text, parameters, prompt);
+        reqParams.dataSources = this.model.dataSources || reqParams.dataSources || []; // add dataSources to the request parameters
+        const {roleInformation, indexName } = parameters; // add roleInformation and indexName to the dataSource if given
+        for(const dataSource of reqParams.dataSources) {
+            if(!dataSource) continue;
+            if(!dataSource.parameters) dataSource.parameters = {};
+            roleInformation && (dataSource.parameters.roleInformation = roleInformation);
+            indexName && (dataSource.parameters.indexName = indexName);
+        }
+        return reqParams;
+    }
+
+    async execute(text, parameters, prompt, pathwayResolver) {
+        const result = await super.execute(text, parameters, prompt, pathwayResolver);
+        pathwayResolver.tool = this.tool; // add tool info back 
+        return result;
+    }
+
+}
+
+export default OpenAIChatExtensionPlugin;

package/server/plugins/openAiChatPlugin.js

@@ -79,12 +79,12 @@ class OpenAIChatPlugin extends ModelPlugin {
     async execute(text, parameters, prompt, pathwayResolver) {
         const url = this.requestUrl(text);
         const requestParameters = this.getRequestParameters(text, parameters, prompt);
-        const requestId = pathwayResolver?.requestId;
+        const { requestId, pathway} = pathwayResolver;
 
         const data = { ...(this.model.params || {}), ...requestParameters };
-        const params = {};
+        const params = {}; // query params
         const headers = this.model.headers || {};
-        return this.executeRequest(url, data, params, headers, prompt, requestId);
+        return this.executeRequest(url, data, params, headers, prompt, requestId, pathway);
     }
 
     // Parse the response from the OpenAI Chat API
@@ -122,12 +122,12 @@ class OpenAIChatPlugin extends ModelPlugin {
         }
     
         if (stream) {
-            console.log(`\x1b[34m> Response is streaming...\x1b[0m`);
+            console.log(`\x1b[34m> [response is an SSE stream]\x1b[0m`);
         } else {
             console.log(`\x1b[34m> ${this.parseResponse(responseData)}\x1b[0m`);
         }
 
-        prompt && prompt.debugInfo && (prompt.debugInfo += `${separator}${JSON.stringify(data)}`);
+        prompt && prompt.debugInfo && (prompt.debugInfo += `\n${JSON.stringify(data)}`);
     }
 }
 

package/server/plugins/openAiCompletionPlugin.js

@@ -79,13 +79,13 @@ class OpenAICompletionPlugin extends ModelPlugin {
     async execute(text, parameters, prompt, pathwayResolver) {
         const url = this.requestUrl(text);
         const requestParameters = this.getRequestParameters(text, parameters, prompt, pathwayResolver);
-        const requestId = pathwayResolver?.requestId;
+        const { requestId, pathway} = pathwayResolver;
 
         const data = { ...(this.model.params || {}), ...requestParameters };
         const params = {};
         const headers = this.model.headers || {};
         
-        return this.executeRequest(url, data, params, headers, prompt, requestId);
+        return this.executeRequest(url, data, params, headers, prompt, requestId, pathway);
     }
 
     // Parse the response from the OpenAI Completion API
@@ -115,12 +115,12 @@ class OpenAICompletionPlugin extends ModelPlugin {
         console.log(`\x1b[36m${modelInput}\x1b[0m`);
 
         if (stream) {
-            console.log(`\x1b[34m> Response is streaming...\x1b[0m`);
+            console.log(`\x1b[34m> [response is an SSE stream]\x1b[0m`);
         } else {
             console.log(`\x1b[34m> ${this.parseResponse(responseData)}\x1b[0m`);
         }
     
-        prompt && prompt.debugInfo && (prompt.debugInfo += `${separator}${JSON.stringify(data)}`);
+        prompt && prompt.debugInfo && (prompt.debugInfo += `\n${JSON.stringify(data)}`);
     }
 }
 

package/server/plugins/openAiWhisperPlugin.js

@@ -129,7 +129,7 @@ class OpenAIWhisperPlugin extends ModelPlugin {
 
                 try {
                     // const res = await axios.post(WHISPER_TS_API_URL, { params: { fileurl: uri } });
-                    const res = await this.executeRequest(WHISPER_TS_API_URL, {fileurl:uri},{},{});
+                    const res = await this.executeRequest(WHISPER_TS_API_URL, {fileurl:uri}, {}, {}, {}, requestId, pathway);
                     return res;
                 } catch (err) {
                     console.log(`Error getting word timestamped data from api:`, err);
@@ -150,7 +150,7 @@ class OpenAIWhisperPlugin extends ModelPlugin {
                 language && formData.append('language', language);
                 modelPromptText && formData.append('prompt', modelPromptText);
 
-                return this.executeRequest(url, formData, params, { ...this.model.headers, ...formData.getHeaders() });
+                return this.executeRequest(url, formData, params, { ...this.model.headers, ...formData.getHeaders() }, {}, requestId, pathway);
             } catch (err) {
                 console.log(err);
                 throw err;
@@ -161,7 +161,7 @@ class OpenAIWhisperPlugin extends ModelPlugin {
         let { file } = parameters;
         let totalCount = 0;
         let completedCount = 0;
-        const { requestId } = pathwayResolver;
+        const { requestId, pathway } = pathwayResolver;
 
         const sendProgress = () => {
             completedCount++;

package/server/plugins/palmChatPlugin.js

@@ -140,7 +140,7 @@ class PalmChatPlugin extends ModelPlugin {
     async execute(text, parameters, prompt, pathwayResolver) {
         const url = this.requestUrl(text);
         const requestParameters = this.getRequestParameters(text, parameters, prompt);
-        const requestId = pathwayResolver?.requestId;
+        const { requestId, pathway} = pathwayResolver;
 
         const data = { ...(this.model.params || {}), ...requestParameters };
         const params = {};
@@ -148,7 +148,7 @@ class PalmChatPlugin extends ModelPlugin {
         const gcpAuthTokenHelper = this.config.get('gcpAuthTokenHelper');
         const authToken = await gcpAuthTokenHelper.getAccessToken();
         headers.Authorization = `Bearer ${authToken}`;
-        return this.executeRequest(url, data, params, headers, prompt, requestId);
+        return this.executeRequest(url, data, params, headers, prompt, requestId, pathway);
     }
 
     // Parse the response from the PaLM Chat API
@@ -219,7 +219,7 @@ class PalmChatPlugin extends ModelPlugin {
         }
     
         if (prompt && prompt.debugInfo) {
-            prompt.debugInfo += `${separator}${JSON.stringify(data)}`;
+            prompt.debugInfo += `\n${JSON.stringify(data)}`;
         }
     }
 }