@aj-archipelago/cortex 1.1.3 → 1.1.4

package/server/plugins/openAiWhisperPlugin.js

@@ -1,57 +1,53 @@
 // openAiWhisperPlugin.js
 import ModelPlugin from './modelPlugin.js';
+import { config } from '../../config.js';
+import subsrt from 'subsrt';
 import FormData from 'form-data';
 import fs from 'fs';
-import { axios } from '../../lib/request.js';
+import { axios } from '../../lib/requestExecutor.js';
 import stream from 'stream';
 import os from 'os';
 import path from 'path';
-import { v4 as uuidv4 } from 'uuid';
-import { config } from '../../config.js';
-import { deleteTempPath } from '../../helper_apps/CortexFileHandler/helper.js';
 import http from 'http';
 import https from 'https';
+import { URL } from 'url';
+import { v4 as uuidv4 } from 'uuid';
 import { promisify } from 'util';
-import subsrt from 'subsrt';
 import { publishRequestProgress } from '../../lib/redisSubscription.js';
 import logger from '../../lib/logger.js';
-
 const pipeline = promisify(stream.pipeline);
 
 const API_URL = config.get('whisperMediaApiUrl');
 const WHISPER_TS_API_URL  = config.get('whisperTSApiUrl');
+if(WHISPER_TS_API_URL){
+    logger.info(`WHISPER API URL using ${WHISPER_TS_API_URL}`);
+}else{
+    logger.warn(`WHISPER API URL not set using default OpenAI API Whisper`);
+}
 
 const OFFSET_CHUNK = 1000 * 60 * 10; // 10 minutes for each chunk
 
-function alignSubtitles(subtitles, format) {
-    const result = [];
-
-    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++) {
-        result.push(...shiftSubtitles(subtitles[i], i * OFFSET_CHUNK));
-    }
-    
+async function deleteTempPath(path) {
     try {
-        //if content has needed html style tags, keep them
-        for(const obj of result) {
-            if(obj && obj.content){ 
-                obj.text = obj.content;
-            }
+        if (!path) {
+            logger.warn('Temporary path is not defined.');
+            return;
         }
-    } catch (error) {
-        logger.error(`An error occurred in content text parsing: ${error}`);
+        if (!fs.existsSync(path)) {
+            logger.warn(`Temporary path ${path} does not exist.`);
+            return;
+        }
+        const stats = fs.statSync(path);
+        if (stats.isFile()) {
+            fs.unlinkSync(path);
+            logger.info(`Temporary file ${path} deleted successfully.`);
+        } else if (stats.isDirectory()) {
+            fs.rmSync(path, { recursive: true });
+            logger.info(`Temporary folder ${path} and its contents deleted successfully.`);
+        }
+    } catch (err) {
+        logger.error(`Error occurred while deleting the temporary path: ${err}`);
     }
-    
-    return subsrt.build(result, { format: format === 'vtt' ? 'vtt' : 'srt' });
 }
 
 function generateUniqueFilename(extension) {
@@ -92,9 +88,49 @@ const downloadFile = async (fileUrl) => {
     });
 };
 
+// convert srt format to text
+function convertToText(str) {
+    return str
+      .split('\n')
+      .filter(line => !line.match(/^\d+$/) && !line.match(/^\d{2}:\d{2}:\d{2},\d{3} --> \d{2}:\d{2}:\d{2},\d{3}$/) && line !== '')
+      .join(' ');
+}
+
+function alignSubtitles(subtitles, format) {
+    const result = [];
+
+    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++) {
+        result.push(...shiftSubtitles(subtitles[i], i * OFFSET_CHUNK));
+    }
+    
+    try {
+        //if content has needed html style tags, keep them
+        for(const obj of result) {
+            if(obj && obj.content){ 
+                obj.text = obj.content;
+            }
+        }
+    } catch (error) {
+        logger.error(`An error occurred in content text parsing: ${error}`);
+    }
+    
+    return subsrt.build(result, { format: format === 'vtt' ? 'vtt' : 'srt' });
+}
+
+
 class OpenAIWhisperPlugin extends ModelPlugin {
-    constructor(config, pathway, modelName, model) {
-        super(config, pathway, modelName, model);
+    constructor(pathway, model) {
+        super(pathway, model);
     }
 
     async getMediaChunks(file, requestId) {
@@ -108,7 +144,7 @@ class OpenAIWhisperPlugin extends ModelPlugin {
                 return [file];
             }
         } catch (err) {
-            logger.error(`Error getting media chunks list from api:`, err);
+            logger.error(`Error getting media chunks list from api: ${err}`);
             throw err;
         }
     }
@@ -118,7 +154,7 @@ class OpenAIWhisperPlugin extends ModelPlugin {
             if (API_URL) {
                 //call helper api to mark processing as completed
                 const res = await axios.delete(API_URL, { params: { requestId } });
-                logger.info(`Marked request ${requestId} as completed: ${res.data}`);
+                logger.info(`Marked request ${requestId} as completed:`, res.data);
                 return res.data;
             }
         } catch (err) {
@@ -127,38 +163,21 @@ class OpenAIWhisperPlugin extends ModelPlugin {
     }
 
     // Execute the request to the OpenAI Whisper API
-    async execute(text, parameters, prompt, pathwayResolver) {
-        const { responseFormat,wordTimestamped,highlightWords,maxLineWidth,maxLineCount,maxWordsPerLine } = parameters;
-        const url = this.requestUrl(text);
-        const params = {};
-        const { modelPromptText } = this.getCompiledPrompt(text, parameters, prompt);
+    async execute(text, parameters, prompt, cortexRequest) {
+        const { pathwayResolver } = cortexRequest;
+        const { responseFormat, wordTimestamped, highlightWords, maxLineWidth, maxLineCount, maxWordsPerLine } = parameters;
+        cortexRequest.url = this.requestUrl(text);
 
-        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 tsparams = { fileurl:uri };
-                    if(highlightWords) tsparams.highlight_words = highlightWords ? "True" : "False";
-                    if(maxLineWidth) tsparams.max_line_width = maxLineWidth;
-                    if(maxLineCount) tsparams.max_line_count = maxLineCount;
-                    if(maxWordsPerLine) tsparams.max_words_per_line = maxWordsPerLine;
-                    if(wordTimestamped!=null) tsparams.word_timestamps = wordTimestamped;
-
-                    const res = await this.executeRequest(WHISPER_TS_API_URL, tsparams, {}, {}, {}, requestId, pathway);
-                    return res;
-                } catch (err) {
-                    logger.error(`Error getting word timestamped data from api: ${err}`);
-                    throw err;
-                }
-            }
-        }
-
-        const processChunk = async (chunk) => {
+        const chunks = [];
+        const processChunk = async (uri) => {
             try {
+                const chunk = await downloadFile(uri);
+                chunks.push(chunk);
+
                 const { language, responseFormat } = parameters;
+                cortexRequest.url = this.requestUrl(text);
+                const params = {};
+                const { modelPromptText } = this.getCompiledPrompt(text, parameters, prompt);
                 const response_format = responseFormat || 'text';
 
                 const formData = new FormData();
@@ -168,9 +187,44 @@ 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() }, {}, requestId, pathway);
+                cortexRequest.data = formData;
+                cortexRequest.params = params;
+                cortexRequest.headers = { ...cortexRequest.headers, ...formData.getHeaders() };
+
+                return this.executeRequest(cortexRequest);
             } catch (err) {
-                logger.error(err);
+                logger.error(`Error getting word timestamped data from api: ${err}`);
+                throw err;
+            }
+        }
+
+        const processTS = async (uri) => {
+            try {
+                const tsparams = { fileurl:uri };
+                if(highlightWords) tsparams.highlight_words = highlightWords ? "True" : "False";
+                if(maxLineWidth) tsparams.max_line_width = maxLineWidth;
+                if(maxLineCount) tsparams.max_line_count = maxLineCount;
+                if(maxWordsPerLine) tsparams.max_words_per_line = maxWordsPerLine;
+                if(wordTimestamped!=null) {
+                    if(!wordTimestamped) {
+                        tsparams.word_timestamps = "False";
+                    }else{
+                        tsparams.word_timestamps = wordTimestamped;    
+                    }
+                }
+
+                cortexRequest.url = WHISPER_TS_API_URL;
+                cortexRequest.data = tsparams;
+
+                const res = await this.executeRequest(cortexRequest);
+
+                if(!wordTimestamped && !responseFormat){ 
+                    //if no response format, convert to text
+                    return convertToText(res);
+                }
+                return res;
+            } catch (err) {
+                logger.error(`Error getting word timestamped data from api: ${err}`);
                 throw err;
             }
         }
@@ -179,59 +233,74 @@ class OpenAIWhisperPlugin extends ModelPlugin {
         let { file } = parameters;
         let totalCount = 0;
         let completedCount = 0;
-        const { requestId, pathway } = pathwayResolver;
-
-        const sendProgress = () => {
-            completedCount++;
+        let partialCount = 0;
+        const { requestId } = pathwayResolver;
+
+        const MAXPARTIALCOUNT = 60;
+        const sendProgress = (partial=false) => {
+            if(partial){
+                partialCount = Math.min(partialCount + 1, MAXPARTIALCOUNT-1);
+            }else {
+                partialCount = 0;
+                completedCount++;
+            }
             if (completedCount >= totalCount) return;
+
+            const progress = (partialCount / MAXPARTIALCOUNT + completedCount) / totalCount;
+            logger.info(`Progress for ${requestId}: ${progress}`);
+
             publishRequestProgress({
-                    requestId,
-                    progress: completedCount / totalCount,
-                    data: null,
+                requestId,
+                progress,
+                data: null,
             });
-            
         }
 
-        let chunks = []; // array of local file paths
+        async function processURI(uri) {
+            let result = null;
+            let _promise = null;
+            if(WHISPER_TS_API_URL){
+                _promise = processTS
+            }else {
+                _promise = processChunk;
+            }
+            _promise(uri).then((ts) => { result = ts;});
+
+            //send updates while waiting for result
+            while(!result) {
+                sendProgress(true);
+                await new Promise(r => setTimeout(r, 3000));
+            }
+            return result;
+        }
+
         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}`);
             }
-            totalCount = uris.length * 4; // 4 steps for each chunk (download and upload)
-            API_URL && (completedCount = uris.length); // api progress is already calculated
+            totalCount = uris.length + 1; // total number of chunks that will be processed
 
-            // sequential download of chunks
+            // sequential process of chunks
             for (const uri of uris) {
-                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.push(await processChunk(chunk));
-                sendProgress();
+                sendProgress(); 
+                const ts = await processURI(uri);
+                result.push(ts);
             }
 
-            // parallel processing, dropped 
-            // result = await Promise.all(mediaSplit.chunks.map(processChunk));
-
         } catch (error) {
-            const errMsg = `Transcribe error: ${error?.message || error}`;
+            const errMsg = `Transcribe error: ${error?.response?.data || error?.message || error}`;
             logger.error(errMsg);
             return errMsg;
         }
         finally {
             try {
                 for (const chunk of chunks) {
-                    await deleteTempPath(chunk);
+                    try {
+                        await deleteTempPath(chunk);
+                    } catch (error) {
+                        //ignore error
+                    } 
                 }
 
                 await this.markCompletedForCleanUp(requestId);
@@ -258,4 +327,3 @@ class OpenAIWhisperPlugin extends ModelPlugin {
 }
 
 export default OpenAIWhisperPlugin;
-

package/server/plugins/palmChatPlugin.js

@@ -5,8 +5,8 @@ import HandleBars from '../../lib/handleBars.js';
 import logger from '../../lib/logger.js';
 
 class PalmChatPlugin extends ModelPlugin {
-    constructor(config, pathway, modelName, model) {
-        super(config, pathway, modelName, model);
+    constructor(pathway, model) {
+        super(pathway, model);
     }
 
     // Convert to PaLM messages array format if necessary
@@ -137,18 +137,17 @@ class PalmChatPlugin extends ModelPlugin {
     }
 
     // Execute the request to the PaLM Chat API
-    async execute(text, parameters, prompt, pathwayResolver) {
-        const url = this.requestUrl(text);
+    async execute(text, parameters, prompt, cortexRequest) {
         const requestParameters = this.getRequestParameters(text, parameters, prompt);
-        const { requestId, pathway} = pathwayResolver;
 
-        const data = { ...(this.model.params || {}), ...requestParameters };
-        const params = {};
-        const headers = this.model.headers || {};
+        cortexRequest.data = { ...(cortexRequest.data || {}), ...requestParameters };
+        cortexRequest.params = {}; // query params
+
         const gcpAuthTokenHelper = this.config.get('gcpAuthTokenHelper');
         const authToken = await gcpAuthTokenHelper.getAccessToken();
-        headers.Authorization = `Bearer ${authToken}`;
-        return this.executeRequest(url, data, params, headers, prompt, requestId, pathway);
+        cortexRequest.headers.Authorization = `Bearer ${authToken}`;
+
+        return this.executeRequest(cortexRequest);
     }
 
     // Parse the response from the PaLM Chat API

package/server/plugins/palmCodeCompletionPlugin.js

@@ -4,8 +4,8 @@ import PalmCompletionPlugin from './palmCompletionPlugin.js';
 
 // PalmCodeCompletionPlugin class for handling requests and responses to the PaLM API Code Completion API
 class PalmCodeCompletionPlugin extends PalmCompletionPlugin {
-    constructor(config, pathway, modelName, model) {
-        super(config, pathway, modelName, model);
+    constructor(pathway, model) {
+        super(pathway, model);
     }
 
     // Set up parameters specific to the PaLM API Code Completion API

package/server/plugins/palmCompletionPlugin.js

@@ -6,8 +6,8 @@ import logger from '../../lib/logger.js';
 
 // PalmCompletionPlugin class for handling requests and responses to the PaLM API Text Completion API
 class PalmCompletionPlugin extends ModelPlugin {
-    constructor(config, pathway, modelName, model) {
-        super(config, pathway, modelName, model);
+    constructor(pathway, model) {
+        super(pathway, model);
     }
 
     truncatePromptIfNecessary (text, textTokenCount, modelMaxTokenCount, targetTextTokenCount, pathwayResolver) {
@@ -54,18 +54,17 @@ class PalmCompletionPlugin extends ModelPlugin {
     }
 
     // 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 { requestId, pathway} = pathwayResolver;
-
-        const data = { ...requestParameters };
-        const params = {};
-        const headers = this.model.headers || {};
+    async execute(text, parameters, prompt, cortexRequest) {
+        const requestParameters = this.getRequestParameters(text, parameters, prompt, cortexRequest.pathwayResolver);
+
+        cortexRequest.data = { ...(cortexRequest.data || {}), ...requestParameters };
+        cortexRequest.params = {}; // query params
+
         const gcpAuthTokenHelper = this.config.get('gcpAuthTokenHelper');
         const authToken = await gcpAuthTokenHelper.getAccessToken();
-        headers.Authorization = `Bearer ${authToken}`;
-        return this.executeRequest(url, data, params, headers, prompt, requestId, pathway);
+        cortexRequest.headers.Authorization = `Bearer ${authToken}`;
+
+        return this.executeRequest(cortexRequest);
     }
 
     // Parse the response from the PaLM API Text Completion API

package/server/resolver.js

@@ -4,7 +4,7 @@ import { PathwayResolver } from './pathwayResolver.js';
 // This resolver uses standard parameters required by Apollo server:
 // (parent, args, contextValue, info)
 const rootResolver = async (parent, args, contextValue, info) => {
-    const { config, pathway, requestState } = contextValue;
+    const { config, pathway } = contextValue;
     const { temperature, enableGraphqlCache } = pathway;
 
     // Turn on graphql caching if enableGraphqlCache true and temperature is 0
@@ -12,7 +12,7 @@ const rootResolver = async (parent, args, contextValue, info) => {
         info.cacheControl.setCacheHint({ maxAge: 60 * 60 * 24, scope: 'PUBLIC' });
     }
 
-    const pathwayResolver = new PathwayResolver({ config, pathway, args, requestState });
+    const pathwayResolver = new PathwayResolver({ config, pathway, args });
     contextValue.pathwayResolver = pathwayResolver;
 
     // Execute the request with timeout

package/server/rest.js

@@ -170,7 +170,7 @@ const processIncomingStream = (requestId, res, jsonResponse) => {
     requestState[requestId].useRedis = false;
     requestState[requestId].started = true;
 
-    resolver(args);
+    resolver && resolver(args);
 
     return subscription;
   

package/tests/config.test.js

@@ -25,7 +25,7 @@ test('config basePathwayPath', (t) => {
 });
 
 test('config PORT', (t) => {
-    const expectedDefault = 4000;
+    const expectedDefault = parseInt(process.env.CORTEX_PORT) || 4000;
     t.is(config.get('PORT'), expectedDefault);
 });
 

package/tests/mocks.js

@@ -6,6 +6,7 @@ export const mockConfig = {
         defaultModelName: 'testModel',
         models: {
           testModel: {
+            name: 'testModel', 
             url: 'https://api.example.com/testModel',
             type: 'OPENAI-COMPLETION',
           },
@@ -40,6 +41,7 @@ export const mockConfig = {
 
   export const mockPathwayResolverString = {
     model: {
+      name: 'testModel',
       url: 'https://api.example.com/testModel',
       type: 'OPENAI-COMPLETION',
     },
@@ -51,6 +53,7 @@ export const mockConfig = {
 
   export const mockPathwayResolverFunction = {
     model: {
+      name: 'testModel',
       url: 'https://api.example.com/testModel',
       type: 'OPENAI-COMPLETION',
     },
@@ -64,6 +67,7 @@ export const mockConfig = {
 
   export const mockPathwayResolverMessages = {
     model: {
+      name: 'testModel',
       url: 'https://api.example.com/testModel',
       type: 'OPENAI-COMPLETION',
     },
@@ -78,3 +82,4 @@ export const mockConfig = {
       }),
   };
 
+  export const mockModelEndpoints = { testModel: { name: 'testModel', url: 'https://api.example.com/testModel', type: 'OPENAI-COMPLETION' }};

package/tests/modelPlugin.test.js

@@ -8,10 +8,10 @@ const DEFAULT_MAX_TOKENS = 4096;
 const DEFAULT_PROMPT_TOKEN_RATIO = 0.5;
 
 // Mock configuration and pathway objects
-const { config, pathway, modelName, model } = mockPathwayResolverString;
+const { config, pathway, model } = mockPathwayResolverString;
 
 test('ModelPlugin constructor', (t) => {
-    const modelPlugin = new ModelPlugin(config, pathway, modelName, model);
+    const modelPlugin = new ModelPlugin(pathway, model);
 
     t.is(modelPlugin.modelName, pathway.model, 'modelName should be set from pathway');
     t.deepEqual(modelPlugin.model, config.get('models')[pathway.model], 'model should be set from config');
@@ -20,7 +20,7 @@ test('ModelPlugin constructor', (t) => {
 });
 
 test.beforeEach((t) => {
-  t.context.modelPlugin = new ModelPlugin(config, pathway, modelName, model);
+  t.context.modelPlugin = new ModelPlugin(pathway, model);
 });
 
 test('getCompiledPrompt - text and parameters', (t) => {
@@ -71,13 +71,6 @@ test('getPromptTokenRatio', (t) => {
     t.is(modelPlugin.getPromptTokenRatio(), DEFAULT_PROMPT_TOKEN_RATIO, 'getPromptTokenRatio should return default prompt token ratio');
 });
 
-test('requestUrl', (t) => {
-    const { modelPlugin } = t.context;
-
-    const expectedUrl = HandleBars.compile(modelPlugin.model.url)({ ...modelPlugin.model, ...config.getEnv(), ...config });
-    t.is(modelPlugin.requestUrl(), expectedUrl, 'requestUrl should return the correct URL');
-});
-
 test('default parseResponse', (t) => {
     const { modelPlugin } = t.context;
     const multipleChoicesResponse = {

package/tests/openAiChatPlugin.test.js

@@ -1,19 +1,20 @@
 import test from 'ava';
 import OpenAIChatPlugin from '../server/plugins/openAiChatPlugin.js';
 import { mockPathwayResolverMessages } from './mocks.js';
+import { config } from '../config.js';
 
-const { config, pathway, modelName, model } = mockPathwayResolverMessages;
+const { pathway, modelName, model } = mockPathwayResolverMessages;
 
 // Test the constructor
 test('constructor', (t) => {
-    const plugin = new OpenAIChatPlugin(config, pathway, modelName, model);
-    t.is(plugin.config, mockPathwayResolverMessages.config);
+    const plugin = new OpenAIChatPlugin(pathway, model);
+    t.is(plugin.config, config);
     t.is(plugin.pathwayPrompt, mockPathwayResolverMessages.pathway.prompt);
 });
 
 // Test the convertPalmToOpenAIMessages function
 test('convertPalmToOpenAIMessages', (t) => {
-    const plugin = new OpenAIChatPlugin(config, pathway, modelName, model);
+    const plugin = new OpenAIChatPlugin(pathway, model);
     const context = 'This is a test context.';
     const examples = [
         {
@@ -37,7 +38,7 @@ test('convertPalmToOpenAIMessages', (t) => {
 
 // Test the getRequestParameters function
 test('getRequestParameters', async (t) => {
-    const plugin = new OpenAIChatPlugin(config, pathway, modelName, model);
+    const plugin = new OpenAIChatPlugin(pathway, model);
     const text = 'Help me';
     const parameters = { name: 'John', age: 30 };
     const prompt = mockPathwayResolverMessages.pathway.prompt;
@@ -59,7 +60,7 @@ test('getRequestParameters', async (t) => {
 
 // Test the execute function
 test('execute', async (t) => {
-    const plugin = new OpenAIChatPlugin(config, pathway, modelName, model);
+    const plugin = new OpenAIChatPlugin(pathway, model);
     const text = 'Help me';
     const parameters = { name: 'John', age: 30 };
     const prompt = mockPathwayResolverMessages.pathway.prompt;
@@ -91,7 +92,7 @@ test('execute', async (t) => {
 
 // Test the parseResponse function
 test('parseResponse', (t) => {
-    const plugin = new OpenAIChatPlugin(config, pathway, modelName, model);
+    const plugin = new OpenAIChatPlugin(pathway, model);
     const data = {
         choices: [
             {
@@ -107,7 +108,7 @@ test('parseResponse', (t) => {
 
 // Test the logRequestData function
 test('logRequestData', (t) => {
-    const plugin = new OpenAIChatPlugin(config, pathway, modelName, model);
+    const plugin = new OpenAIChatPlugin(pathway, model);
     const data = {
         messages: [
             { role: 'user', content: 'User: Help me\nAssistant: Please help John who is 30 years old.' },

package/tests/openai_api.test.js

@@ -5,7 +5,7 @@ import got from 'got';
 import axios from 'axios';
 import serverFactory from '../index.js';
 
-const API_BASE = 'http://localhost:4000/v1';
+const API_BASE = `http://localhost:${process.env.CORTEX_PORT}/v1`;
 
 let testServer;
 
@@ -110,7 +110,7 @@ test('POST SSE: /v1/completions should send a series of events and a [DONE] even
         stream: true,
     };
     
-    const url = 'http://localhost:4000/v1';
+    const url = `http://localhost:${process.env.CORTEX_PORT}/v1`;
     
     const completionsAssertions = (t, messageJson) => {
         t.truthy(messageJson.id);
@@ -133,7 +133,7 @@ test('POST SSE: /v1/chat/completions should send a series of events and a [DONE]
         stream: true,
     };
     
-    const url = 'http://localhost:4000/v1';
+    const url = `http://localhost:${process.env.CORTEX_PORT}/v1`;
     
     const chatCompletionsAssertions = (t, messageJson) => {
         t.truthy(messageJson.id);

package/tests/palmChatPlugin.test.js

@@ -6,7 +6,7 @@ import { mockPathwayResolverMessages } from './mocks.js';
 const { config, pathway, modelName, model } = mockPathwayResolverMessages;
 
 test.beforeEach((t) => {
-  const palmChatPlugin = new PalmChatPlugin(config, pathway, modelName, model);
+  const palmChatPlugin = new PalmChatPlugin(pathway, model);
   t.context = { palmChatPlugin };
 });
 

package/tests/palmCompletionPlugin.test.js

@@ -7,7 +7,7 @@ import { mockPathwayResolverString } from './mocks.js';
 const { config, pathway, modelName, model } = mockPathwayResolverString;
 
 test.beforeEach((t) => {
-  const palmCompletionPlugin = new PalmCompletionPlugin(config, pathway, modelName, model);
+  const palmCompletionPlugin = new PalmCompletionPlugin(pathway, model);
   t.context = { palmCompletionPlugin };
 });