@aj-archipelago/cortex 1.1.4 → 1.1.6

package/server/pathwayResolver.js

@@ -2,7 +2,7 @@ import { ModelExecutor } from './modelExecutor.js';
 import { modelEndpoints } from '../lib/requestExecutor.js';
 // eslint-disable-next-line import/no-extraneous-dependencies
 import { v4 as uuidv4 } from 'uuid';
-import { encode } from 'gpt-3-encoder';
+import { encode } from '../lib/encodeCache.js';
 import { getFirstNToken, getLastNToken, getSemanticChunks } from './chunker.js';
 import { PathwayResponseParser } from './pathwayResponseParser.js';
 import { Prompt } from './prompt.js';
@@ -98,8 +98,9 @@ class PathwayResolver {
                     const incomingMessage = responseData;
 
                     let messageBuffer = '';
+                    let streamEnded = false;
 
-                    const processData = (data) => {
+                    const processStreamSSE = (data) => {
                         try {
                             //logger.info(`\n\nReceived stream data for requestId ${this.requestId}: ${data.toString()}`);
                             let events = data.toString().split('\n');
@@ -132,18 +133,35 @@ class PathwayResolver {
                                             return;
                                         }
 
+                                        // error can be in different places in the message
                                         const streamError = parsedMessage?.error || parsedMessage?.choices?.[0]?.delta?.content?.error || parsedMessage?.choices?.[0]?.text?.error;
                                         if (streamError) {
                                             streamErrorOccurred = true;
                                             logger.error(`Stream error: ${streamError.message}`);
-                                            incomingMessage.off('data', processData); // Stop listening to 'data'
+                                            incomingMessage.off('data', processStreamSSE);
                                             return;
                                         }
+
+                                        // finish reason can be in different places in the message
+                                        const finishReason = parsedMessage?.choices?.[0]?.finish_reason || parsedMessage?.candidates?.[0]?.finishReason;
+                                        if (finishReason?.toLowerCase() === 'stop') {
+                                            requestProgress.progress = 1;
+                                        } else {
+                                            if (finishReason?.toLowerCase() === 'safety') {
+                                                const safetyRatings = JSON.stringify(parsedMessage?.candidates?.[0]?.safetyRatings) || '';
+                                                logger.warn(`Request ${this.requestId} was blocked by the safety filter. ${safetyRatings}`);
+                                                requestProgress.data = `\n\nResponse blocked by safety filter: ${safetyRatings}`;
+                                                requestProgress.progress = 1;
+                                            }
+                                        }
                                     }
 
                                     try {
-                                        //logger.info(`Publishing stream message to requestId ${this.requestId}: ${message}`);
-                                        publishRequestProgress(requestProgress);
+                                        if (!streamEnded) {
+                                            //logger.info(`Publishing stream message to requestId ${this.requestId}: ${message}`);
+                                            publishRequestProgress(requestProgress);
+                                            streamEnded = requestProgress.progress === 1;
+                                        }
                                     } catch (error) {
                                         logger.error(`Could not publish the stream message: "${messageBuffer}", ${error}`);
                                     }
@@ -156,7 +174,7 @@ class PathwayResolver {
 
                     if (incomingMessage) {
                         await new Promise((resolve, reject) => {
-                            incomingMessage.on('data', processData);
+                            incomingMessage.on('data', processStreamSSE);
                             incomingMessage.on('end', resolve);
                             incomingMessage.on('error', reject);
                         });
@@ -321,7 +339,7 @@ class PathwayResolver {
             const data = await Promise.all(chunks.map(chunk =>
                 this.applyPromptsSerially(chunk, parameters)));
             // Join the chunks with newlines
-            return data.join("\n\n");
+            return data.join(this.pathway.joinChunksWith || "\n\n");
         } else {
             // Apply prompts one by one, serially, across all chunks
             // This is the default processing mode and will make previousResult available at the object level
@@ -355,7 +373,7 @@ class PathwayResolver {
                     if (result.length === 1) {
                         result = result[0];
                     } else if (!currentParameters.stream) {
-                        result = result.join("\n\n");
+                        result = result.join(this.pathway.joinChunksWith || "\n\n");
                     }
                 }
 

package/server/plugins/azureCognitivePlugin.js

@@ -6,6 +6,7 @@ import path from 'path';
 import { config } from '../../config.js';
 import { axios } from '../../lib/requestExecutor.js';
 import logger from '../../lib/logger.js';
+import { getSemanticChunks } from '../chunker.js';
 
 const API_URL = config.get('whisperMediaApiUrl');
 
@@ -37,7 +38,8 @@ class AzureCognitivePlugin extends ModelPlugin {
         const data = {};
 
         if (mode == 'delete') {
-            const searchUrl = this.ensureMode(this.requestUrl(text), 'search');
+            let searchUrl = this.ensureMode(this.requestUrl(text), 'search');
+            searchUrl = this.ensureIndex(searchUrl, indexName);
             let searchQuery = `owner:${savedContextId}`;
             
             if (docId) {
@@ -155,6 +157,7 @@ class AzureCognitivePlugin extends ModelPlugin {
         const headers = cortexRequest.headers;
 
         const { file } = parameters;
+        const fileData = { value: [] };
         if(file){ 
             let url = file;
             //if not txt file, use helper app to convert to txt
@@ -177,11 +180,13 @@ class AzureCognitivePlugin extends ModelPlugin {
                 throw Error(`No data can be extracted out of file!`);
             }
 
-            return await callPathway('cognitive_insert', {...parameters, file:null, text:data });
-        }
+            const chunkTokenLength = this.promptParameters.inputChunkSize || 1000;
+            const chunks = getSemanticChunks(data, chunkTokenLength);
 
-        if (mode === 'index' && (!text || !text.trim()) ){
-            return; // nothing to index
+            for (const text of chunks) {
+                const { data: singleData } = await this.getRequestParameters(text, parameters, prompt, mode, indexName, savedContextId, cortexRequest) 
+                fileData.value.push(singleData.value[0]);
+            }
         }
 
         const { data, params } = await this.getRequestParameters(text, parameters, prompt, mode, indexName, savedContextId, cortexRequest);
@@ -195,7 +200,7 @@ class AzureCognitivePlugin extends ModelPlugin {
 
         // execute the request
         cortexRequest.url = url;
-        cortexRequest.data = data;
+        cortexRequest.data = (mode === 'index' && fileData.value.length>0) ? fileData : data;
         cortexRequest.params = params;
         cortexRequest.headers = headers;
         const result = await this.executeRequest(cortexRequest);

package/server/plugins/azureTranslatePlugin.js

@@ -45,8 +45,6 @@ class AzureTranslatePlugin extends ModelPlugin {
     
     // Override the logging function to display the request and response
     logRequestData(data, responseData, prompt) {
-        this.logAIRequestFinished();
-    
         const modelInput = data[0].Text;
     
         logger.debug(`${modelInput}`);

package/server/plugins/geminiChatPlugin.js

@@ -0,0 +1,192 @@
+// geminiChatPlugin.js
+import ModelPlugin from './modelPlugin.js';
+import logger from '../../lib/logger.js';
+
+const mergeResults = (data) => {
+    let output = '';
+    let safetyRatings = [];
+
+    for (let chunk of data) {
+        const { candidates } = chunk;
+        if (!candidates || !candidates.length) {
+            continue;
+        }
+
+        // If it was blocked, return the blocked message
+        if (candidates[0].safetyRatings.some(rating => rating.blocked)) {
+            safetyRatings = candidates[0].safetyRatings;
+            return {mergedResult: 'The response was blocked because the input or response potentially violates policies. Try rephrasing the prompt or adjusting the parameter settings.', safetyRatings: safetyRatings};
+        }
+
+        // Append the content of the first part of the first candidate to the output
+        const message = candidates[0].content.parts[0].text;
+        output += message;
+    }
+
+    return {mergedResult: output || null, safetyRatings: safetyRatings};
+};
+
+class GeminiChatPlugin extends ModelPlugin {
+    constructor(pathway, model) {
+        super(pathway, model);
+    }
+
+    // This code converts either OpenAI or PaLM messages to the Gemini messages format
+    convertMessagesToGemini(messages) {
+        let modifiedMessages = [];
+        let lastAuthor = '';
+
+        // Check if the messages are already in the Gemini format
+        if (messages[0] && Object.prototype.hasOwnProperty.call(messages[0], 'parts')) {
+            modifiedMessages = messages;
+        } else {
+            messages.forEach(message => {
+                const { role, author, content } = message;
+        
+                // Right now Gemini API has no direct translation for system messages,
+                // but they work fine as parts of user messages
+                if (role === 'system') {
+                    modifiedMessages.push({
+                        role: 'user',
+                        parts: [{ text: content }],
+                    });
+                    lastAuthor = 'user';
+                    return;
+                }
+        
+                // Aggregate consecutive author messages, appending the content
+                if ((role === lastAuthor || author === lastAuthor) && modifiedMessages.length > 0) {
+                    modifiedMessages[modifiedMessages.length - 1].parts.push({ text: content });
+                }
+
+                // Push messages that are role: 'user' or 'assistant', changing 'assistant' to 'model'
+                else if (role === 'user' || role === 'assistant' || author) {
+                    modifiedMessages.push({
+                        role: author || role,
+                        parts: [{ text: content }],
+                    });
+                    lastAuthor = author || role;
+                }
+            });
+        }
+    
+        // Gemini requires an even number of messages
+        if (modifiedMessages.length % 2 === 0) {
+            modifiedMessages = modifiedMessages.slice(1);
+        }
+
+        return {
+            modifiedMessages,
+        };
+    }
+
+    // Set up parameters specific to the Gemini API
+    getRequestParameters(text, parameters, prompt, cortexRequest) {
+        const { modelPromptText, modelPromptMessages, tokenLength } = this.getCompiledPrompt(text, parameters, prompt);
+        const { geminiSafetySettings, geminiTools, max_tokens } = cortexRequest ? cortexRequest.pathway : {};
+
+        // Define the model's max token length
+        const modelTargetTokenLength = this.getModelMaxTokenLength() * this.getPromptTokenRatio();
+    
+        const geminiMessages = this.convertMessagesToGemini(modelPromptMessages || [{ "role": "user", "parts": [{ "text": modelPromptText }]}]);
+        
+        let requestMessages = geminiMessages.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);
+        }
+        
+        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.`);
+        }
+    
+        const requestParameters = {
+        contents: requestMessages,
+        generationConfig: {
+            temperature: this.temperature || 0.7,
+            maxOutputTokens: max_tokens || this.getModelMaxReturnTokens(),
+            topP: parameters.topP || 0.95,
+            topK: parameters.topK || 40,
+        },
+        safety_settings: geminiSafetySettings || undefined,
+        tools: geminiTools || undefined
+        };
+    
+        return requestParameters;
+    }
+
+    // Parse the response from the new Chat API
+    parseResponse(data) {
+        // If data is not an array, return it directly
+        if (!Array.isArray(data)) {
+            return data;
+        }
+
+        return mergeResults(data).mergedResult || null;
+    
+    }
+
+    // Execute the request to the new Chat API
+    async execute(text, parameters, prompt, cortexRequest) {
+        const requestParameters = this.getRequestParameters(text, parameters, prompt, cortexRequest);
+        const { stream } = parameters;
+
+        cortexRequest.data = { ...(cortexRequest.data || {}), ...requestParameters };
+        cortexRequest.params = {}; // query params
+        cortexRequest.stream = stream;
+        cortexRequest.url = cortexRequest.stream ? `${cortexRequest.url}?alt=sse` : cortexRequest.url;
+
+        const gcpAuthTokenHelper = this.config.get('gcpAuthTokenHelper');
+        const authToken = await gcpAuthTokenHelper.getAccessToken();
+        cortexRequest.headers.Authorization = `Bearer ${authToken}`;
+
+        return this.executeRequest(cortexRequest);
+    }
+
+    // Override the logging function to display the messages and responses
+    logRequestData(data, responseData, prompt) {
+        const messages = data && data.contents;
+        
+        if (messages && messages.length > 1) {
+            logger.info(`[chat request contains ${messages.length} messages]`);
+            messages.forEach((message, index) => {
+                const messageContent = message.parts.reduce((acc, part) => {
+                    if (part.text) {
+                        return acc + part.text;
+                    }
+                    return acc;
+                } , '');
+                const words = messageContent.split(" ");
+                const { length, units } = this.getLength(messageContent);
+                const preview = words.length < 41 ? messageContent : words.slice(0, 20).join(" ") + " ... " + words.slice(-20).join(" ");
+    
+                logger.debug(`message ${index + 1}: role: ${message.role}, ${units}: ${length}, content: "${preview}"`);
+            });
+        } else if (messages && messages.length === 1) {
+            logger.debug(`${messages[0].parts[0].text}`);
+        }
+
+        // check if responseData is an array
+        if (!Array.isArray(responseData)) {
+            logger.info(`[response received as an SSE stream]`);    
+        } else {
+            const { mergedResult, safetyRatings } = mergeResults(responseData);
+            if (safetyRatings?.length) {
+                logger.warn(`!!! response was blocked because the input or response potentially violates policies`);
+                logger.debug(`Safety Ratings: ${JSON.stringify(safetyRatings, null, 2)}`);
+            }
+            const { length, units } = this.getLength(mergedResult);
+            logger.info(`[response received containing ${length} ${units}]`);
+            logger.debug(`${mergedResult}`);
+        }
+
+        if (prompt && prompt.debugInfo) {
+            prompt.debugInfo += `\n${JSON.stringify(data)}`;
+        }
+    }
+
+}
+
+export default GeminiChatPlugin;

package/server/plugins/geminiVisionPlugin.js

@@ -0,0 +1,102 @@
+import GeminiChatPlugin from './geminiChatPlugin.js';
+import mime from 'mime-types';
+import logger from '../../lib/logger.js';
+
+class GeminiVisionPlugin extends GeminiChatPlugin {
+
+    // Override the convertMessagesToGemini method to handle multimodal vision messages
+    // This function can operate on messages in Gemini native format or in OpenAI's format
+    // It will convert the messages to the Gemini format
+    convertMessagesToGemini(messages) {
+        let modifiedMessages = [];
+        let lastAuthor = '';
+    
+        // Check if the messages are already in the Gemini format
+        if (messages[0] && Object.prototype.hasOwnProperty.call(messages[0], 'parts')) {
+            modifiedMessages = messages;
+        } else {
+            messages.forEach(message => {
+                const { role, author, content } = message;
+    
+                // Right now Gemini API has no direct translation for system messages,
+                // so we insert them as parts of the first user: role message
+                if (role === 'system') {
+                    modifiedMessages.push({
+                        role: 'user',
+                        parts: [{ text: content }],
+                    });
+                    lastAuthor = 'user';
+                    return;
+                }
+    
+                // Convert content to Gemini format, trying to maintain compatibility
+                const convertPartToGemini = (partString) => {
+                    try {
+                        const part = JSON.parse(partString);
+                        if (typeof part === 'string') {
+                            return { text: part };
+                        } else if (part.type === 'text') {
+                            return { text: part.text };
+                        } else if (part.type === 'image_url') {
+                            if (part.image_url.url.startsWith('gs://')) {
+                                return {
+                                    fileData: {
+                                        mimeType: mime.lookup(part.image_url.url),
+                                        fileUri: part.image_url.url
+                                    }
+                                };
+                            } else {
+                                return {
+                                    inlineData: {
+                                        mimeType: 'image/jpeg', // fixed for now as there's no MIME type in the request
+                                        data: part.image_url.url.split('base64,')[1]
+                                    }
+                                };
+                            }
+                        }
+                    } catch (e) {
+                        logger.warn(`Unable to parse part - including as string: ${partString}`);
+                    }
+                    return { text: partString };
+                };
+    
+                const addPartToMessages = (geminiPart) => {
+                    // Gemini requires alternating user: and model: messages
+                    if ((role === lastAuthor || author === lastAuthor) && modifiedMessages.length > 0) {
+                        modifiedMessages[modifiedMessages.length - 1].parts.push(geminiPart);
+                    }
+                    // Gemini only supports user: and model: roles
+                    else if (role === 'user' || role === 'assistant' || author) {
+                        modifiedMessages.push({
+                            role: author || role,
+                            parts: [geminiPart],
+                        });
+                        lastAuthor = author || role;
+                    }
+                };
+
+                // Content can either be in the "vision" format (array) or in the "chat" format (string)
+                if (Array.isArray(content)) {
+                    content.forEach(part => {
+                        addPartToMessages(convertPartToGemini(part));
+                    });
+                } 
+                else {
+                    addPartToMessages(convertPartToGemini(content));
+                }
+            });
+        }
+    
+        // Gemini requires an even number of messages
+        if (modifiedMessages.length % 2 === 0) {
+            modifiedMessages = modifiedMessages.slice(1);
+        }
+    
+        return {
+            modifiedMessages,
+        };
+    }
+
+}
+
+export default GeminiVisionPlugin;

package/server/plugins/localModelPlugin.js

@@ -1,7 +1,7 @@
 // localModelPlugin.js
 import ModelPlugin from './modelPlugin.js';
 import { execFileSync } from 'child_process';
-import { encode } from 'gpt-3-encoder';
+import { encode } from '../../lib/encodeCache.js';
 import logger from '../../lib/logger.js';
 
 class LocalModelPlugin extends ModelPlugin {

package/server/plugins/modelPlugin.js

@@ -1,7 +1,7 @@
 // ModelPlugin.js
 import HandleBars from '../../lib/handleBars.js';
 import { executeRequest } from '../../lib/requestExecutor.js';
-import { encode } from 'gpt-3-encoder';
+import { encode } from '../../lib/encodeCache.js';
 import { getFirstNToken } from '../chunker.js';
 import logger, { obscureUrlParams } from '../../lib/logger.js';
 import { config } from '../../config.js';
@@ -32,7 +32,6 @@ class ModelPlugin {
         }
 
         this.requestCount = 0;
-        this.lastRequestStartTime = new Date();
     }
 
     truncateMessagesToTargetLength(messages, targetTokenLength) {
@@ -221,7 +220,6 @@ class ModelPlugin {
     // Default simple logging
     logRequestStart() {
         this.requestCount++;
-        this.lastRequestStartTime = new Date();
         const logMessage = `>>> [${this.requestId}: ${this.pathwayName}.${this.requestCount}] request`;
         const header = '>'.repeat(logMessage.length);
         logger.info(`${header}`);
@@ -229,28 +227,32 @@ class ModelPlugin {
         logger.info(`>>> Making API request to ${obscureUrlParams(this.url)}`);
     }
 
-    logAIRequestFinished() {
-        const currentTime = new Date();
-        const timeElapsed = (currentTime - this.lastRequestStartTime) / 1000;
-        const logMessage = `<<< [${this.requestId}: ${this.pathwayName}] response - complete in ${timeElapsed}s - data:`;
+    logAIRequestFinished(requestDuration) {
+        const logMessage = `<<< [${this.requestId}: ${this.pathwayName}] response - complete in ${requestDuration}ms - data:`;
         const header = '<'.repeat(logMessage.length);
         logger.info(`${header}`);
         logger.info(`${logMessage}`);
     }
 
+    getLength(data) {
+        const isProd = config.get('env') === 'production';
+        const length = isProd ? data.length : encode(data).length;
+        const units = isProd ? 'characters' : 'tokens';
+        return {length, units};
+    }
+
     logRequestData(data, responseData, prompt) {
-        this.logAIRequestFinished(); 
         const modelInput = data.prompt || (data.messages && data.messages[0].content) || (data.length > 0 && data[0].Text) || null;
     
         if (modelInput) {
-            const inputTokens = encode(modelInput).length;
-            logger.info(`[request sent containing ${inputTokens} tokens]`);
+            const { length, units } = this.getLength(modelInput);
+            logger.info(`[request sent containing ${length} ${units}]`);
             logger.debug(`${modelInput}`);
         }
     
-        const responseText = JSON.stringify(this.parseResponse(responseData));
-        const responseTokens = encode(responseText).length;
-        logger.info(`[response received containing ${responseTokens} tokens]`);
+        const responseText = JSON.stringify(responseData);
+        const { length, units } = this.getLength(responseText);
+        logger.info(`[response received containing ${length} ${units}]`);
         logger.debug(`${responseText}`);
     
         prompt && prompt.debugInfo && (prompt.debugInfo += `\n${JSON.stringify(data)}`);
@@ -267,15 +269,18 @@ class ModelPlugin {
             cortexRequest.cache = config.get('enableCache') && (pathway.enableCache || pathway.temperature == 0);
             this.logRequestStart();
 
-            const responseData = await executeRequest(cortexRequest);
+            const { data: responseData, duration: requestDuration } = await executeRequest(cortexRequest);
             
-            if (responseData.error) {
-                logger.error(`An error was returned from the server: ${JSON.stringify(responseData.error)}`);
-                throw responseData;
+            const errorData = Array.isArray(responseData) ? responseData[0] : responseData;
+            if (errorData && errorData.error) {
+                throw new Error(`Server error: ${JSON.stringify(errorData.error)}`);
             }
         
-            this.logRequestData(data, responseData, prompt);
-            return this.parseResponse(responseData);
+            this.logAIRequestFinished(requestDuration);
+            const parsedData = this.parseResponse(responseData);
+            this.logRequestData(data, parsedData, prompt);
+
+            return parsedData;
         } catch (error) {
             // Log the error and continue
             logger.error(error.message || error);

package/server/plugins/openAiChatPlugin.js

@@ -1,6 +1,5 @@
 // OpenAIChatPlugin.js
 import ModelPlugin from './modelPlugin.js';
-import { encode } from 'gpt-3-encoder';
 import logger from '../../lib/logger.js';
 
 class OpenAIChatPlugin extends ModelPlugin {
@@ -105,28 +104,28 @@ class OpenAIChatPlugin extends ModelPlugin {
 
     // Override the logging function to display the messages and responses
     logRequestData(data, responseData, prompt) {
-        this.logAIRequestFinished();
-    
         const { stream, messages } = data;
         if (messages && messages.length > 1) {
             logger.info(`[chat request sent containing ${messages.length} messages]`);
-            let totalTokens = 0;
+            let totalLength = 0;
+            let totalUnits;
             messages.forEach((message, index) => {
                 //message.content string or array
                 const content = Array.isArray(message.content) ? message.content.map(item => JSON.stringify(item)).join(', ') : message.content;
                 const words = content.split(" ");
-                const tokenCount = encode(content).length;
+                const { length, units } = this.getLength(content);
                 const preview = words.length < 41 ? content : words.slice(0, 20).join(" ") + " ... " + words.slice(-20).join(" ");
     
-                logger.debug(`Message ${index + 1}: Role: ${message.role}, Tokens: ${tokenCount}, Content: "${preview}"`);
-                totalTokens += tokenCount;
+                logger.debug(`message ${index + 1}: role: ${message.role}, ${units}: ${length}, content: "${preview}"`);
+                totalLength += length;
+                totalUnits = units;
             });
-            logger.info(`[chat request contained ${totalTokens} tokens]`);
+            logger.info(`[chat request contained ${totalLength} ${totalUnits}]`);
         } else {
             const message = messages[0];
             const content = Array.isArray(message.content) ? message.content.map(item => JSON.stringify(item)).join(', ') : message.content;
-            const tokenCount = encode(content).length;
-            logger.info(`[request sent containing ${tokenCount} tokens]`);
+            const { length, units } = this.getLength(content);
+            logger.info(`[request sent containing ${length} ${units}]`);
             logger.debug(`${content}`);
         }
     
@@ -134,8 +133,8 @@ class OpenAIChatPlugin extends ModelPlugin {
             logger.info(`[response received as an SSE stream]`);
         } else {
             const responseText = this.parseResponse(responseData);
-            const responseTokens = encode(responseText).length;
-            logger.info(`[response received containing ${responseTokens} tokens]`);
+            const { length, units } = this.getLength(responseText);
+            logger.info(`[response received containing ${length} ${units}]`);
             logger.debug(`${responseText}`);
         }
 

package/server/plugins/openAiCompletionPlugin.js

@@ -1,7 +1,7 @@
 // OpenAICompletionPlugin.js
 
 import ModelPlugin from './modelPlugin.js';
-import { encode } from 'gpt-3-encoder';
+import { encode } from '../../lib/encodeCache.js';
 import logger from '../../lib/logger.js';
 
 // Helper function to truncate the prompt if it is too long
@@ -104,21 +104,20 @@ class OpenAICompletionPlugin extends ModelPlugin {
 
     // Override the logging function to log the prompt and response
     logRequestData(data, responseData, prompt) {
-        this.logAIRequestFinished();
-    
         const stream = data.stream;
         const modelInput = data.prompt;
     
-        const modelInputTokens = encode(modelInput).length;
-        logger.info(`[request sent containing ${modelInputTokens} tokens]`);
+        const { length, units } = this.getLength(modelInput);
+
+        logger.info(`[request sent containing ${length} ${units}]`);
         logger.debug(`${modelInput}`);
 
         if (stream) {
             logger.info(`[response received as an SSE stream]`);
         } else {
             const responseText = this.parseResponse(responseData);
-            const responseTokens = encode(responseText).length;
-            logger.info(`[response received containing ${responseTokens} tokens]`);
+            const { length, units } = this.getLength(responseText);
+            logger.info(`[response received containing ${length} ${units}]`);
             logger.debug(`${responseText}`);
         }
     

package/server/plugins/openAiEmbeddingsPlugin.js

@@ -7,11 +7,13 @@ class OpenAiEmbeddingsPlugin extends ModelPlugin {
     }
 
     getRequestParameters(text, parameters, prompt) {
-        const combinedParameters = { ...this.promptParameters, ...parameters };
+        const combinedParameters = { ...this.promptParameters, ...this.model.params, ...parameters };
         const { modelPromptText } = this.getCompiledPrompt(text, combinedParameters, prompt);
+        const { model } = combinedParameters;
         const requestParameters = {
             data:  {
                 input: combinedParameters?.input?.length ? combinedParameters.input :  modelPromptText || text,
+                model
             }
         };
         return requestParameters;

package/server/plugins/openAiWhisperPlugin.js

@@ -201,6 +201,9 @@ class OpenAIWhisperPlugin extends ModelPlugin {
         const processTS = async (uri) => {
             try {
                 const tsparams = { fileurl:uri };
+
+                const { language } = parameters;
+                if(language) tsparams.language = language;
                 if(highlightWords) tsparams.highlight_words = highlightWords ? "True" : "False";
                 if(maxLineWidth) tsparams.max_line_width = maxLineWidth;
                 if(maxLineCount) tsparams.max_line_count = maxLineCount;