@aj-archipelago/cortex 1.0.4 → 1.0.6

package/server/plugins/openAiChatPlugin.js

@@ -0,0 +1,134 @@
+// OpenAIChatPlugin.js
+import ModelPlugin from './modelPlugin.js';
+import { encode } from 'gpt-3-encoder';
+
+class OpenAIChatPlugin extends ModelPlugin {
+    constructor(config, pathway) {
+        super(config, pathway);
+    }
+
+    // convert to OpenAI messages array format if necessary
+    convertPalmToOpenAIMessages(context, examples, messages) {
+        let openAIMessages = [];
+        
+        // Add context as a system message
+        if (context) {
+            openAIMessages.push({
+            role: 'system',
+            content: context,
+            });
+        }
+        
+        // Add examples to the messages array
+        examples.forEach(example => {
+            openAIMessages.push({
+            role: example.input.author || 'user',
+            content: example.input.content,
+            });
+            openAIMessages.push({
+            role: example.output.author || 'assistant',
+            content: example.output.content,
+            });
+        });
+        
+        // Add remaining messages to the messages array
+        messages.forEach(message => {
+            openAIMessages.push({
+            role: message.author,
+            content: message.content,
+            });
+        });
+        
+        return openAIMessages;
+    }
+
+    // Set up parameters specific to the OpenAI Chat API
+    getRequestParameters(text, parameters, prompt) {
+        const { modelPromptText, modelPromptMessages, tokenLength, modelPrompt } = this.getCompiledPrompt(text, parameters, prompt);
+        const { stream } = parameters;
+    
+        // Define the model's max token length
+        const modelTargetTokenLength = this.getModelMaxTokenLength() * this.getPromptTokenRatio();
+    
+        let requestMessages = modelPromptMessages || [{ "role": "user", "content": modelPromptText }];
+        
+        // Check if the messages are in Palm format and convert them to OpenAI format if necessary
+        const isPalmFormat = requestMessages.some(message => 'author' in message);
+        if (isPalmFormat) {
+            const context = modelPrompt.context || '';
+            const examples = modelPrompt.examples || [];
+            requestMessages = this.convertPalmToOpenAIMessages(context, examples, expandedMessages);
+        }
+    
+        // Check if the token length exceeds the model's max token length
+        if (tokenLength > modelTargetTokenLength) {
+            // Remove older messages until the token length is within the model's limit
+            requestMessages = this.truncateMessagesToTargetLength(requestMessages, modelTargetTokenLength);
+        }
+    
+        const requestParameters = {
+        messages: requestMessages,
+        temperature: this.temperature ?? 0.7,
+        ...(stream !== undefined ? { stream } : {}),
+        };
+    
+        return requestParameters;
+    }
+
+    // Execute the request to the OpenAI Chat API
+    async execute(text, parameters, prompt) {
+        const url = this.requestUrl(text);
+        const requestParameters = this.getRequestParameters(text, parameters, prompt);
+
+        const data = { ...(this.model.params || {}), ...requestParameters };
+        const params = {};
+        const headers = this.model.headers || {};
+        return this.executeRequest(url, data, params, headers, prompt);
+    }
+
+    // Parse the response from the OpenAI Chat 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
+        const messageResult = choices[0].message && choices[0].message.content && choices[0].message.content.trim();
+        return messageResult ?? null;
+    }
+
+    // Override the logging function to display the messages and responses
+    logRequestData(data, responseData, prompt) {
+        const separator = `\n=== ${this.pathwayName}.${this.requestCount++} ===\n`;
+        console.log(separator);
+    
+        const { stream, messages } = data;
+        if (messages && messages.length > 1) {
+            messages.forEach((message, index) => {
+                const words = message.content.split(" ");
+                const tokenCount = encode(message.content).length;
+                const preview = words.length < 41 ? message.content : words.slice(0, 20).join(" ") + " ... " + words.slice(-20).join(" ");
+    
+                console.log(`\x1b[36mMessage ${index + 1}: Role: ${message.role}, Tokens: ${tokenCount}, Content: "${preview}"\x1b[0m`);
+            });
+        } else {
+            console.log(`\x1b[36m${messages[0].content}\x1b[0m`);
+        }
+    
+        if (stream) {
+            console.log(`\x1b[34m> Response is streaming...\x1b[0m`);
+        } else {
+            console.log(`\x1b[34m> ${this.parseResponse(responseData)}\x1b[0m`);
+        }
+
+        prompt && prompt.debugInfo && (prompt.debugInfo += `${separator}${JSON.stringify(data)}`);
+    }
+}
+
+export default OpenAIChatPlugin;

package/{graphql → server}/plugins/openAiCompletionPlugin.js

@@ -1,7 +1,6 @@
 // OpenAICompletionPlugin.js
 
 import ModelPlugin from './modelPlugin.js';
-
 import { encode } from 'gpt-3-encoder';
 
 // Helper function to truncate the prompt if it is too long
@@ -52,7 +51,7 @@ class OpenAICompletionPlugin extends ModelPlugin {
                 frequency_penalty: 0,
                 presence_penalty: 0,
                 stop: ["<|im_end|>"],
-                stream
+                ...(stream !== undefined ? { stream } : {}),
             };
         } else {
 
@@ -83,8 +82,45 @@ class OpenAICompletionPlugin extends ModelPlugin {
         const data = { ...(this.model.params || {}), ...requestParameters };
         const params = {};
         const headers = this.model.headers || {};
+        
         return this.executeRequest(url, data, params, headers, prompt);
     }
+
+    // Parse the response from the OpenAI Completion 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
+        const textResult = choices[0].text && choices[0].text.trim();
+        return textResult ?? null;
+    }
+
+    // Override the logging function to log the prompt and response
+    logRequestData(data, responseData, prompt) {
+        const separator = `\n=== ${this.pathwayName}.${this.requestCount++} ===\n`;
+        console.log(separator);
+    
+        const stream = data.stream;
+        const modelInput = data.prompt;
+    
+        console.log(`\x1b[36m${modelInput}\x1b[0m`);
+
+        if (stream) {
+            console.log(`\x1b[34m> Response is streaming...\x1b[0m`);
+        } else {
+            console.log(`\x1b[34m> ${this.parseResponse(responseData)}\x1b[0m`);
+        }
+    
+        prompt && prompt.debugInfo && (prompt.debugInfo += `${separator}${JSON.stringify(data)}`);
+    }
 }
 
 export default OpenAICompletionPlugin;

package/{graphql → server}/plugins/openAiWhisperPlugin.js

@@ -14,10 +14,33 @@ import http from 'http';
 import https from 'https';
 import url from 'url';
 import { promisify } from 'util';
+import subsrt from 'subsrt';
 const pipeline = promisify(stream.pipeline);
 
 
 const API_URL = config.get('whisperMediaApiUrl');
+const WHISPER_TS_API_URL  = config.get('whisperTSApiUrl');
+
+function alignSubtitles(subtitles) {
+    const result = [];
+    const offset = 1000 * 60 * 10; // 10 minutes for each chunk
+
+    function preprocessStr(str) {
+        return str.trim().replace(/(\n\n)(?!\n)/g, '\n\n\n');
+    }
+
+    function shiftSubtitles(subtitle, shiftOffset) {
+        const captions = subsrt.parse(preprocessStr(subtitle));
+        const resynced = subsrt.resync(captions, { offset: shiftOffset });
+        return resynced;
+    }
+
+    for (let i = 0; i < subtitles.length; i++) {
+        const subtitle = subtitles[i];
+        result.push(...shiftSubtitles(subtitle, i * offset));
+    }
+    return subsrt.build(result);
+}
 
 function generateUniqueFilename(extension) {
     return `${uuidv4()}.${extension}`;
@@ -93,17 +116,37 @@ class OpenAIWhisperPlugin extends ModelPlugin {
 
     // Execute the request to the OpenAI Whisper API
     async execute(text, parameters, prompt, pathwayResolver) {
+        const { responseFormat, wordTimestamped } = parameters;
         const url = this.requestUrl(text);
         const params = {};
         const { modelPromptText } = this.getCompiledPrompt(text, parameters, prompt);
 
+        const processTS = async (uri) => {
+            if (wordTimestamped) {
+                if (!WHISPER_TS_API_URL) {
+                    throw new Error(`WHISPER_TS_API_URL not set for word timestamped processing`);
+                }
+
+                try {
+                    // const res = await axios.post(WHISPER_TS_API_URL, { params: { fileurl: uri } });
+                    const res = await this.executeRequest(WHISPER_TS_API_URL, {fileurl:uri},{},{});
+                    return res;
+                } catch (err) {
+                    console.log(`Error getting word timestamped data from api:`, err);
+                    throw err;
+                }
+            }
+        }
+
         const processChunk = async (chunk) => {
             try {
-                const { language } = parameters;
+                const { language, responseFormat } = parameters;
+                const response_format = responseFormat || 'text';
+
                 const formData = new FormData();
                 formData.append('file', fs.createReadStream(chunk));
                 formData.append('model', this.model.params.model);
-                formData.append('response_format', 'text');
+                formData.append('response_format', response_format);
                 language && formData.append('language', language);
                 modelPromptText && formData.append('prompt', modelPromptText);
 
@@ -114,7 +157,7 @@ class OpenAIWhisperPlugin extends ModelPlugin {
             }
         }
 
-        let result = ``;
+        let result = [];
         let { file } = parameters;
         let totalCount = 0;
         let completedCount = 0;
@@ -134,7 +177,6 @@ class OpenAIWhisperPlugin extends ModelPlugin {
 
         let chunks = []; // array of local file paths
         try {
-
             const uris = await this.getMediaChunks(file, requestId); // array of remote file uris
             if (!uris || !uris.length) {
                 throw new Error(`Error in getting chunks from media helper for file ${file}`);
@@ -144,14 +186,20 @@ class OpenAIWhisperPlugin extends ModelPlugin {
 
             // sequential download of chunks
             for (const uri of uris) {
-                chunks.push(await downloadFile(uri));
+                if (wordTimestamped) { // get word timestamped data 
+                    sendProgress(); // no download needed auto progress 
+                    const ts = await processTS(uri);
+                    result.push(ts);
+                } else {
+                    chunks.push(await downloadFile(uri));
+                }
                 sendProgress();
             }
 
 
             // sequential processing of chunks
             for (const chunk of chunks) {
-                result += await processChunk(chunk);
+                result.push(await processChunk(chunk));
                 sendProgress();
             }
 
@@ -184,7 +232,11 @@ class OpenAIWhisperPlugin extends ModelPlugin {
                 console.error("An error occurred while deleting:", error);
             }
         }
-        return result;
+
+        if (['srt','vtt'].includes(responseFormat) || wordTimestamped) { // align subtitles for formats
+            return alignSubtitles(result);
+        }
+        return result.join(` `);
     }
 }
 

package/server/plugins/palmChatPlugin.js

@@ -0,0 +1,229 @@
+// palmChatPlugin.js
+import ModelPlugin from './modelPlugin.js';
+import { encode } from 'gpt-3-encoder';
+import HandleBars from '../../lib/handleBars.js';
+
+class PalmChatPlugin extends ModelPlugin {
+    constructor(config, pathway) {
+        super(config, pathway);
+    }
+
+    // Convert to PaLM messages array format if necessary
+    convertMessagesToPalm(messages) {
+        let context = '';
+        let modifiedMessages = [];
+        let lastAuthor = '';
+    
+        messages.forEach(message => {
+            const { role, author, content } = message;
+    
+            // Extract system messages into the context string
+            if (role === 'system') {
+                context += (context.length > 0 ? '\n' : '') + content;
+                return;
+            }
+     
+            // Aggregate consecutive author messages, appending the content
+            if ((role === lastAuthor || author === lastAuthor) && modifiedMessages.length > 0) {
+                modifiedMessages[modifiedMessages.length - 1].content += '\n' + content;
+            }
+            // Only push messages with role 'user' or 'assistant' or existing author messages
+            else if (role === 'user' || role === 'assistant' || author) {
+                modifiedMessages.push({
+                    author: author || role,
+                    content,
+                });
+                lastAuthor = author || role;
+            }
+        });
+    
+        return {
+            modifiedMessages,
+            context,
+        };
+    }
+
+    // Handlebars compiler for context (PaLM chat specific)
+    getCompiledContext(text, parameters, context) {
+        const combinedParameters = { ...this.promptParameters, ...parameters };
+        return context ? HandleBars.compile(context)({ ...combinedParameters, text}) : '';
+    }
+
+    // Handlebars compiler for examples (PaLM chat specific)
+    getCompiledExamples(text, parameters, examples = []) {
+        const combinedParameters = { ...this.promptParameters, ...parameters };
+
+        const compileContent = (content) => {
+            const compile = HandleBars.compile(content);
+            return compile({ ...combinedParameters, text });
+        };
+
+        const processExample = (example, key) => {
+            if (example[key]?.content) {
+                return { ...example[key], content: compileContent(example[key].content) };
+            }
+            return { ...example[key] };
+        };
+
+        return examples.map((example) => ({
+            input: example.input ? processExample(example, 'input') : undefined,
+            output: example.output ? processExample(example, 'output') : undefined,
+        }));
+    }
+
+    // Set up parameters specific to the PaLM Chat API
+    getRequestParameters(text, parameters, prompt) {
+        const { modelPromptText, modelPromptMessages, tokenLength } = this.getCompiledPrompt(text, parameters, prompt);
+        const { stream } = parameters;
+    
+        // Define the model's max token length
+        const modelTargetTokenLength = this.getModelMaxTokenLength() * this.getPromptTokenRatio();
+    
+        const palmMessages = this.convertMessagesToPalm(modelPromptMessages || [{ "author": "user", "content": modelPromptText }]);
+        
+        let requestMessages = palmMessages.modifiedMessages;
+
+        // Check if the token length exceeds the model's max token length
+        if (tokenLength > modelTargetTokenLength) {
+            // Remove older messages until the token length is within the model's limit
+            requestMessages = this.truncateMessagesToTargetLength(requestMessages, modelTargetTokenLength);
+        }
+
+        const context = this.getCompiledContext(text, parameters, prompt.context || palmMessages.context || '');
+        const examples = this.getCompiledExamples(text, parameters, prompt.examples || []);
+        
+        // For PaLM right now, the max return tokens is 1024, regardless of the max context length
+        // I can't think of a time you'd want to constrain it to fewer at the moment.
+        const max_tokens = 1024//this.getModelMaxTokenLength() - tokenLength;
+    
+        if (max_tokens < 0) {
+            throw new Error(`Prompt is too long to successfully call the model at ${tokenLength} tokens.  The model will not be called.`);
+        }
+    
+        // Ensure there are an even number of messages (PaLM requires an even number of messages)
+        if (requestMessages.length % 2 === 0) {
+            requestMessages = requestMessages.slice(1);
+        }
+
+        const requestParameters = {
+            instances: [{
+                context: context,
+                examples: examples,
+                messages: requestMessages,
+            }],
+            parameters: {
+                temperature: this.temperature ?? 0.7,
+                maxOutputTokens: max_tokens,
+                topP: parameters.topP ?? 0.95,
+                topK: parameters.topK ?? 40,
+            }
+        };
+    
+        return requestParameters;
+    }
+
+    // Get the safetyAttributes from the PaLM Chat API response data
+    getSafetyAttributes(data) {
+        const { predictions } = data;
+        if (!predictions || !predictions.length) {
+            return null;
+        }
+
+        // if we got a predictions array back with more than one prediction, return the safetyAttributes of the first prediction
+        if (predictions.length > 1) {
+            return predictions[0].safetyAttributes ?? null;
+        }
+
+        // otherwise, return the safetyAttributes of the content of the first prediction
+        return predictions[0].safetyAttributes ?? null;
+    }
+
+    // Execute the request to the PaLM Chat API
+    async execute(text, parameters, prompt) {
+        const url = this.requestUrl(text);
+        const requestParameters = this.getRequestParameters(text, parameters, prompt);
+
+        const data = { ...(this.model.params || {}), ...requestParameters };
+        const params = {};
+        const headers = this.model.headers || {};
+        const gcpAuthTokenHelper = this.config.get('gcpAuthTokenHelper');
+        const authToken = await gcpAuthTokenHelper.getAccessToken();
+        headers.Authorization = `Bearer ${authToken}`;
+        return this.executeRequest(url, data, params, headers, prompt);
+    }
+
+    // Parse the response from the PaLM Chat API
+    parseResponse(data) {
+        const { predictions } = data;
+        if (!predictions || !predictions.length) {
+            return null;
+        }
+    
+        // Get the candidates array from the first prediction
+        const { candidates } = predictions[0];
+
+        // if it was blocked, return the blocked message
+        if (predictions[0].safetyAttributes?.blocked) {
+            return 'The response is blocked because the input or response potentially violates Google policies. Try rephrasing the prompt or adjusting the parameter settings. Currently, only English is supported.';
+        }
+
+        if (!candidates || !candidates.length) {
+            return null;
+        }
+    
+        // If we got a candidates array back with more than one candidate, return the whole array
+        if (candidates.length > 1) {
+            return candidates;
+        }
+    
+        // Otherwise, return the content of the first candidate
+        const messageResult = candidates[0].content && candidates[0].content.trim();
+        return messageResult ?? null;
+    }
+
+    // Override the logging function to display the messages and responses
+    logRequestData(data, responseData, prompt) {
+        const separator = `\n=== ${this.pathwayName}.${this.requestCount++} ===\n`;
+        console.log(separator);
+    
+        const instances = data && data.instances;
+        const messages = instances && instances[0] && instances[0].messages;
+        const { context, examples } = instances && instances [0] || {};
+    
+        if (context) {
+            console.log(`\x1b[36mContext: ${context}\x1b[0m`);
+        }
+
+        if (examples && examples.length) {
+            examples.forEach((example, index) => {
+                console.log(`\x1b[36mExample ${index + 1}: Input: "${example.input.content}", Output: "${example.output.content}"\x1b[0m`);
+            });
+        }
+        
+        if (messages && messages.length > 1) {
+            messages.forEach((message, index) => {
+                const words = message.content.split(" ");
+                const tokenCount = encode(message.content).length;
+                const preview = words.length < 41 ? message.content : words.slice(0, 20).join(" ") + " ... " + words.slice(-20).join(" ");
+    
+                console.log(`\x1b[36mMessage ${index + 1}: Author: ${message.author}, Tokens: ${tokenCount}, Content: "${preview}"\x1b[0m`);
+            });
+        } else if (messages && messages.length === 1) {
+            console.log(`\x1b[36m${messages[0].content}\x1b[0m`);
+        }
+
+        const safetyAttributes = this.getSafetyAttributes(responseData);
+
+        console.log(`\x1b[34m> ${this.parseResponse(responseData)}\x1b[0m`);
+
+        if (safetyAttributes) {
+            console.log(`\x1b[33mSafety Attributes: ${JSON.stringify(safetyAttributes, null, 2)}\x1b[0m`);
+        }
+    
+        if (prompt && prompt.debugInfo) {
+            prompt.debugInfo += `${separator}${JSON.stringify(data)}`;
+        }
+    }
+}
+
+export default PalmChatPlugin;

package/server/plugins/palmCompletionPlugin.js

@@ -0,0 +1,134 @@
+// palmCompletionPlugin.js
+
+import ModelPlugin from './modelPlugin.js';
+
+// Helper function to truncate the prompt if it is too long
+const truncatePromptIfNecessary = (text, textTokenCount, modelMaxTokenCount, targetTextTokenCount, pathwayResolver) => {
+    const maxAllowedTokens = textTokenCount + ((modelMaxTokenCount - targetTextTokenCount) * 0.5);
+
+    if (textTokenCount > maxAllowedTokens) {
+        pathwayResolver.logWarning(`Prompt is too long at ${textTokenCount} tokens (this target token length for this pathway is ${targetTextTokenCount} tokens because the response is expected to take up the rest of the model's max tokens (${modelMaxTokenCount}). Prompt will be truncated.`);
+        return pathwayResolver.truncate(text, maxAllowedTokens);
+    }
+    return text;
+}
+
+// PalmCompletionPlugin class for handling requests and responses to the PaLM API Text Completion API
+class PalmCompletionPlugin extends ModelPlugin {
+    constructor(config, pathway) {
+        super(config, pathway);
+    }
+
+    // Set up parameters specific to the PaLM API Text Completion API
+    getRequestParameters(text, parameters, prompt, pathwayResolver) {
+        const { modelPromptText, tokenLength } = this.getCompiledPrompt(text, parameters, prompt);
+        const { stream } = parameters;
+        // Define the model's max token length
+        const modelTargetTokenLength = this.getModelMaxTokenLength() * this.getPromptTokenRatio();
+    
+        const truncatedPrompt = truncatePromptIfNecessary(modelPromptText, tokenLength, this.getModelMaxTokenLength(), modelTargetTokenLength, pathwayResolver);
+    
+        const max_tokens = 1024//this.getModelMaxTokenLength() - tokenLength;
+    
+        if (max_tokens < 0) {
+            throw new Error(`Prompt is too long to successfully call the model at ${tokenLength} tokens.  The model will not be called.`);
+        }
+
+        if (!truncatedPrompt) {
+            throw new Error(`Prompt is empty.  The model will not be called.`);
+        }
+    
+        const requestParameters = {
+            instances: [
+                { prompt: truncatedPrompt }
+            ],
+            parameters: {
+                temperature: this.temperature ?? 0.7,
+                maxOutputTokens: max_tokens,
+                topP: parameters.topP ?? 0.95,
+                topK: parameters.topK ?? 40,
+            }
+        };
+    
+        return requestParameters;
+    }
+
+    // Execute the request to the PaLM API Text Completion API
+    async execute(text, parameters, prompt, pathwayResolver) {
+        const url = this.requestUrl(text);
+        const requestParameters = this.getRequestParameters(text, parameters, prompt, pathwayResolver);
+
+        const data = { ...requestParameters };
+        const params = {};
+        const headers = this.model.headers || {};
+        const gcpAuthTokenHelper = this.config.get('gcpAuthTokenHelper');
+        const authToken = await gcpAuthTokenHelper.getAccessToken();
+        headers.Authorization = `Bearer ${authToken}`;
+        return this.executeRequest(url, data, params, headers, prompt);
+    }
+
+    // Parse the response from the PaLM API Text Completion API
+    parseResponse(data) {
+        const { predictions } = data;
+        if (!predictions || !predictions.length) {
+            return data;
+        }
+
+        // if we got a predictions array back with more than one prediction, return the whole array
+        if (predictions.length > 1) {
+            return predictions;
+        }
+
+        // otherwise, return the content of the first prediction
+        // if it was blocked, return the blocked message
+        if (predictions[0].safetyAttributes?.blocked) {
+            return 'The response is blocked because the input or response potentially violates Google policies. Try rephrasing the prompt or adjusting the parameter settings. Currently, only English is supported.';
+        }
+
+        const contentResult = predictions[0].content && predictions[0].content.trim();
+        return contentResult ?? null;
+    }
+
+    // Get the safetyAttributes from the PaLM API Text Completion API response data
+    getSafetyAttributes(data) {
+        const { predictions } = data;
+        if (!predictions || !predictions.length) {
+            return null;
+        }
+
+        // if we got a predictions array back with more than one prediction, return the safetyAttributes of the first prediction
+        if (predictions.length > 1) {
+            return predictions[0].safetyAttributes ?? null;
+        }
+
+        // otherwise, return the safetyAttributes of the content of the first prediction
+        return predictions[0].safetyAttributes ?? null;
+    }
+
+    // Override the logging function to log the prompt and response
+    logRequestData(data, responseData, prompt) {
+        const separator = `\n=== ${this.pathwayName}.${this.requestCount++} ===\n`;
+        console.log(separator);
+
+        const safetyAttributes = this.getSafetyAttributes(responseData);
+
+        const instances = data && data.instances;
+        const modelInput = instances && instances[0] && instances[0].prompt;
+
+        if (modelInput) {
+            console.log(`\x1b[36m${modelInput}\x1b[0m`);
+        }
+
+        console.log(`\x1b[34m> ${this.parseResponse(responseData)}\x1b[0m`);
+
+        if (safetyAttributes) {
+            console.log(`\x1b[33mSafety Attributes: ${JSON.stringify(safetyAttributes, null, 2)}\x1b[0m`);
+        }
+
+        if (prompt && prompt.debugInfo) {
+            prompt.debugInfo += `${separator}${JSON.stringify(data)}`;
+        }
+    }
+}
+
+export default PalmCompletionPlugin;