@aj-archipelago/cortex 1.1.2 → 1.1.4-0

package/server/{pathwayPrompter.js → modelExecutor.js}

@@ -1,4 +1,6 @@
-// PathwayPrompter.js
+// ModelExecutor.js
+import CortexRequest from '../lib/cortexRequest.js';
+
 import OpenAIChatPlugin from './plugins/openAiChatPlugin.js';
 import OpenAICompletionPlugin from './plugins/openAiCompletionPlugin.js';
 import AzureTranslatePlugin from './plugins/azureTranslatePlugin.js';
@@ -16,59 +18,59 @@ import OpenAIImagePlugin from './plugins/openAiImagePlugin.js';
 import OpenAIDallE3Plugin from './plugins/openAiDallE3Plugin.js';
 import OpenAIVisionPlugin from './plugins/openAiVisionPlugin.js';
 
-class PathwayPrompter {
-    constructor(config, pathway, modelName, model) {
+class ModelExecutor {
+    constructor(pathway, model) {
 
         let plugin;
 
         switch (model.type) {
             case 'OPENAI-CHAT':
-                plugin = new OpenAIChatPlugin(config, pathway, modelName, model);
+                plugin = new OpenAIChatPlugin(pathway, model);
                 break;
             case 'OPENAI-DALLE2':
-                plugin = new OpenAIImagePlugin(config, pathway, modelName, model);
+                plugin = new OpenAIImagePlugin(pathway, model);
                 break;
             case 'OPENAI-DALLE3':
-                plugin = new OpenAIDallE3Plugin(config, pathway, modelName, model);
+                plugin = new OpenAIDallE3Plugin(pathway, model);
                 break;
             case 'OPENAI-CHAT-EXTENSION':
-                plugin = new OpenAIChatExtensionPlugin(config, pathway, modelName, model);
+                plugin = new OpenAIChatExtensionPlugin(pathway, model);
                 break;
             case 'AZURE-TRANSLATE':
-                plugin = new AzureTranslatePlugin(config, pathway, modelName, model);
+                plugin = new AzureTranslatePlugin(pathway, model);
                 break;
             case 'AZURE-COGNITIVE':
-                plugin = new AzureCognitivePlugin(config, pathway, modelName, model);
+                plugin = new AzureCognitivePlugin(pathway, model);
                 break;
             case 'OPENAI-EMBEDDINGS':
-                plugin = new OpenAiEmbeddingsPlugin(config, pathway, modelName, model);
+                plugin = new OpenAiEmbeddingsPlugin(pathway, model);
                 break;
             case 'OPENAI-COMPLETION':
-                plugin = new OpenAICompletionPlugin(config, pathway, modelName, model);
+                plugin = new OpenAICompletionPlugin(pathway, model);
                 break;
             case 'OPENAI-WHISPER':
-                plugin = new OpenAIWhisperPlugin(config, pathway, modelName, model);
+                plugin = new OpenAIWhisperPlugin(pathway, model);
                 break;
             case 'LOCAL-CPP-MODEL':
-                plugin = new LocalModelPlugin(config, pathway, modelName, model);
+                plugin = new LocalModelPlugin(pathway, model);
                 break;
             case 'PALM-CHAT':
-                plugin = new PalmChatPlugin(config, pathway, modelName, model);
+                plugin = new PalmChatPlugin(pathway, model);
                 break;
             case 'PALM-COMPLETION':
-                plugin = new PalmCompletionPlugin(config, pathway, modelName, model);
+                plugin = new PalmCompletionPlugin(pathway, model);
                 break;
             case 'PALM-CODE-COMPLETION':
-                plugin = new PalmCodeCompletionPlugin(config, pathway, modelName, model);
+                plugin = new PalmCodeCompletionPlugin(pathway, model);
                 break;
             case 'COHERE-GENERATE':
-                plugin = new CohereGeneratePlugin(config, pathway, modelName, model);
+                plugin = new CohereGeneratePlugin(pathway, model);
                 break;
             case 'COHERE-SUMMARIZE':
-                plugin = new CohereSummarizePlugin(config, pathway, modelName, model);
+                plugin = new CohereSummarizePlugin(pathway, model);
                 break;
             case 'OPENAI-VISION':
-                plugin = new OpenAIVisionPlugin(config, pathway, modelName, model);
+                plugin = new OpenAIVisionPlugin(pathway, model);
                 break;
             default:
                 throw new Error(`Unsupported model type: ${model.type}`);
@@ -78,10 +80,11 @@ class PathwayPrompter {
     }
 
     async execute(text, parameters, prompt, pathwayResolver) {
-        return await this.plugin.execute(text, parameters, prompt, pathwayResolver);
+        const cortexRequest = new CortexRequest({ pathwayResolver });
+        return await this.plugin.execute(text, parameters, prompt, cortexRequest);
     }
 }
 
 export {
-    PathwayPrompter
+    ModelExecutor
 };

package/server/pathwayResolver.js

@@ -1,4 +1,5 @@
-import { PathwayPrompter } from './pathwayPrompter.js';
+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';
@@ -14,7 +15,9 @@ import logger from '../lib/logger.js';
 const modelTypesExcludedFromProgressUpdates = ['OPENAI-DALLE2', 'OPENAI-DALLE3'];
 
 class PathwayResolver {
-    constructor({ config, pathway, args }) {
+    // Optional endpoints override parameter is for testing purposes
+    constructor({ config, pathway, args, endpoints }) {
+        this.endpoints = endpoints || modelEndpoints;
         this.config = config;
         this.pathway = pathway;
         this.args = args;
@@ -28,8 +31,8 @@ class PathwayResolver {
             args?.model,
             pathway.inputParameters?.model,
             config.get('defaultModelName')
-            ].find(modelName => modelName && Object.prototype.hasOwnProperty.call(config.get('models'), modelName));
-        this.model = config.get('models')[this.modelName];
+            ].find(modelName => modelName && Object.prototype.hasOwnProperty.call(this.endpoints, modelName));
+        this.model = this.endpoints[this.modelName];
 
         if (!this.model) {
             throw new Error(`Model ${this.modelName} not found in config`);
@@ -47,7 +50,7 @@ class PathwayResolver {
 
         this.previousResult = '';
         this.prompts = [];
-        this.pathwayPrompter = new PathwayPrompter(this.config, this.pathway, this.modelName, this.model);
+        this.modelExecutor = new ModelExecutor(this.pathway, this.model);
 
         Object.defineProperty(this, 'pathwayPrompt', {
             get() {
@@ -70,7 +73,7 @@ class PathwayResolver {
     // 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, useRedis = true) {
+    async asyncResolve(args) {
         const MAX_RETRY_COUNT = 3;
         let attempt = 0;
         let streamErrorOccurred = false;
@@ -88,7 +91,7 @@ class PathwayResolver {
                             requestId: this.requestId,
                             progress: completedCount / totalCount,
                             data: JSON.stringify(responseData),
-                    }, useRedis);
+                    });
                 }
             } else {
                 try {
@@ -140,7 +143,7 @@ class PathwayResolver {
 
                                     try {
                                         //logger.info(`Publishing stream message to requestId ${this.requestId}: ${message}`);
-                                        publishRequestProgress(requestProgress, useRedis);
+                                        publishRequestProgress(requestProgress);
                                     } catch (error) {
                                         logger.error(`Could not publish the stream message: "${messageBuffer}", ${error}`);
                                     }
@@ -255,7 +258,7 @@ class PathwayResolver {
     }
 
     truncate(str, n) {
-        if (this.pathwayPrompter.plugin.promptParameters.truncateFromFront) {
+        if (this.modelExecutor.plugin.promptParameters.truncateFromFront) {
             return getFirstNToken(str, n);
         }
         return getLastNToken(str, n);
@@ -263,7 +266,7 @@ class PathwayResolver {
 
     async summarizeIfEnabled({ text, ...parameters }) {
         if (this.pathway.useInputSummarization) {
-            return await callPathway(this.config, 'summary', { ...this.args, ...parameters, targetLength: 0});
+            return await callPathway('summary', { ...this.args, ...parameters, targetLength: 0});
         }
         return text;
     }
@@ -271,15 +274,15 @@ class PathwayResolver {
     // Calculate the maximum token length for a chunk
     getChunkMaxTokenLength() {
         // find the longest prompt
-        const maxPromptTokenLength = Math.max(...this.prompts.map((promptData) => this.pathwayPrompter.plugin.getCompiledPrompt('', this.args, promptData).tokenLength));
+        const maxPromptTokenLength = Math.max(...this.prompts.map((promptData) => this.modelExecutor.plugin.getCompiledPrompt('', this.args, promptData).tokenLength));
         
         // find out if any prompts use both text input and previous result
         const hasBothProperties = this.prompts.some(prompt => prompt.usesTextInput && prompt.usesPreviousResult);
         
         // the token ratio is the ratio of the total prompt to the result text - both have to be included
         // in computing the max token length
-        const promptRatio = this.pathwayPrompter.plugin.getPromptTokenRatio();
-        let chunkMaxTokenLength = promptRatio * this.pathwayPrompter.plugin.getModelMaxTokenLength() - maxPromptTokenLength - 1;
+        const promptRatio = this.modelExecutor.plugin.getPromptTokenRatio();
+        let chunkMaxTokenLength = promptRatio * this.modelExecutor.plugin.getModelMaxTokenLength() - maxPromptTokenLength - 1;
         
         // if we have to deal with prompts that have both text input
         // and previous result, we need to split the maxChunkToken in half
@@ -386,20 +389,22 @@ class PathwayResolver {
 
         // If this text is empty, skip applying the prompt as it will likely be a nonsensical result
         if (!/^\s*$/.test(text) || parameters?.file || parameters?.inputVector || this?.modelName.includes('cognitive')) {
-            result = await this.pathwayPrompter.execute(text, { ...parameters, ...this.savedContext }, prompt, this);
+            result = await this.modelExecutor.execute(text, { ...parameters, ...this.savedContext }, prompt, this);
         } else {
             result = text;
         }
         
         requestState[this.requestId].completedCount++;
 
-        const { completedCount, totalCount } = requestState[this.requestId];
+        if (parameters.async) {
+            const { completedCount, totalCount } = requestState[this.requestId];
 
-        if (completedCount < totalCount) {
-            await publishRequestProgress({
-                    requestId: this.requestId,
-                    progress: completedCount / totalCount,
-            });
+            if (completedCount < totalCount) {
+                await publishRequestProgress({
+                        requestId: this.requestId,
+                        progress: completedCount / totalCount,
+                });
+            }
         }
 
         if (prompt.saveResultTo) {

package/server/plugins/azureCognitivePlugin.js

@@ -4,7 +4,7 @@ import ModelPlugin from './modelPlugin.js';
 import { v4 as uuidv4 } from 'uuid';
 import path from 'path';
 import { config } from '../../config.js';
-import { axios } from '../../lib/request.js';
+import { axios } from '../../lib/requestExecutor.js';
 import logger from '../../lib/logger.js';
 
 const API_URL = config.get('whisperMediaApiUrl');
@@ -14,8 +14,8 @@ const TOP = 1000;
 let DIRECT_FILE_EXTENSIONS = [".txt", ".json", ".csv", ".md", ".xml", ".js", ".html", ".css"];
 
 class AzureCognitivePlugin extends ModelPlugin {
-    constructor(config, pathway, modelName, model) {
-        super(config, pathway, modelName, model);
+    constructor(pathway, model) {
+        super(pathway, model);
     }
 
     async getInputVector (text) {
@@ -23,14 +23,14 @@ class AzureCognitivePlugin extends ModelPlugin {
             if(!text || !text.trim()){
                 return;
             }
-            return JSON.parse(await callPathway(this.config, 'embeddings', { text }))[0];
+            return JSON.parse(await callPathway('embeddings', { text }))[0];
         }catch(err){
             logger.error(`Error in calculating input vector for text: ${text}, error: ${err}`);
         }
     }
 
     // Set up parameters specific to the Azure Cognitive API
-    async getRequestParameters(text, parameters, prompt, mode, indexName, savedContextId,  {headers, requestId, pathway, _url}) {
+    async getRequestParameters(text, parameters, prompt, mode, indexName, savedContextId, cortexRequest) {
         const combinedParameters = { ...this.promptParameters, ...parameters };
         const { modelPromptText } = this.getCompiledPrompt(text, combinedParameters, prompt);
         const { inputVector, calculateInputVector, privateData, filter, docId } = combinedParameters;
@@ -44,13 +44,15 @@ class AzureCognitivePlugin extends ModelPlugin {
                 searchQuery += ` AND docId:'${docId}'`;
             }
 
-            const docsToDelete = JSON.parse(await this.executeRequest(searchUrl,
-                { search: searchQuery,  
-                    "searchMode": "all",
-                    "queryType": "full",
-                    select: 'id', top: TOP 
-                },
-                {}, headers, prompt, requestId, pathway));
+            cortexRequest.url = searchUrl;
+            cortexRequest.data =
+            { search: searchQuery,  
+                "searchMode": "all",
+                "queryType": "full",
+                select: 'id', top: TOP 
+            };
+
+            const docsToDelete = JSON.parse(await this.executeRequest(cortexRequest));
         
             const value = docsToDelete.value.map(({id}) => ({
                 id,
@@ -144,13 +146,13 @@ class AzureCognitivePlugin extends ModelPlugin {
     }
 
     // Execute the request to the Azure Cognitive API
-    async execute(text, parameters, prompt, pathwayResolver) {
-        const { requestId, pathway, savedContextId, savedContext } = pathwayResolver;
+    async execute(text, parameters, prompt, cortexRequest) {
+        const { requestId, savedContextId, savedContext } = cortexRequest.pathwayResolver;
         const mode = this.promptParameters.mode || 'search';
         let url = this.ensureMode(this.requestUrl(text), mode == 'delete' ? 'index' : mode);
         const indexName = parameters.indexName || 'indexcortex';
         url = this.ensureIndex(url, indexName);
-        const headers = this.model.headers;
+        const headers = cortexRequest.headers;
 
         const { file } = parameters;
         if(file){ 
@@ -175,15 +177,14 @@ class AzureCognitivePlugin extends ModelPlugin {
                 throw Error(`No data can be extracted out of file!`);
             }
 
-            //return await this.execute(data, {...parameters, file:null}, prompt, pathwayResolver); 
-            return await callPathway(this.config, 'cognitive_insert', {...parameters, file:null, text:data });
+            return await callPathway('cognitive_insert', {...parameters, file:null, text:data });
         }
 
         if (mode === 'index' && (!text || !text.trim()) ){
             return; // nothing to index
         }
 
-        const { data, params } = await this.getRequestParameters(text, parameters, prompt, mode, indexName, savedContextId, {headers, requestId, pathway, url});
+        const { data, params } = await this.getRequestParameters(text, parameters, prompt, mode, indexName, savedContextId, cortexRequest);
 
         // update contextid last used
         savedContext["lastUsed"] = new Date().toISOString();
@@ -193,11 +194,15 @@ class AzureCognitivePlugin extends ModelPlugin {
         }
 
         // execute the request
-        const result = await this.executeRequest(url, data || {}, params || {}, headers || {}, prompt, requestId, pathway);
+        cortexRequest.url = url;
+        cortexRequest.data = data;
+        cortexRequest.params = params;
+        cortexRequest.headers = headers;
+        const result = await this.executeRequest(cortexRequest);
 
         // if still has more to delete
         if (mode === 'delete' && data?.value?.length == TOP) { 
-            return await this.execute(text, parameters, prompt, pathwayResolver);
+            return await this.execute(text, parameters, prompt, cortexRequest);
         }
         
         return result;

package/server/plugins/azureTranslatePlugin.js

@@ -3,8 +3,8 @@ import ModelPlugin from './modelPlugin.js';
 import logger from '../../lib/logger.js';
 
 class AzureTranslatePlugin extends ModelPlugin {
-    constructor(config, pathway, modelName, model) {
-        super(config, pathway, modelName, model);
+    constructor(pathway, model) {
+        super(pathway, model);
     }
     
     // Set up parameters specific to the Azure Translate API
@@ -25,17 +25,13 @@ class AzureTranslatePlugin extends ModelPlugin {
     }
 
     // Execute the request to the Azure Translate API
-    async execute(text, parameters, prompt, pathwayResolver) {
+    async execute(text, parameters, prompt, cortexRequest) {
         const requestParameters = this.getRequestParameters(text, parameters, prompt);
-        const { requestId, pathway} = pathwayResolver;
 
-        const url = this.requestUrl(text);
+        cortexRequest.data = requestParameters.data;
+        cortexRequest.params = requestParameters.params;
 
-        const data = requestParameters.data;
-        const params = requestParameters.params;
-        const headers = this.model.headers || {};
-
-        return this.executeRequest(url, data, params, headers, prompt, requestId, pathway);
+        return this.executeRequest(cortexRequest);
     }
     
     // Parse the response from the Azure Translate API

package/server/plugins/cohereGeneratePlugin.js

@@ -2,8 +2,8 @@
 import ModelPlugin from './modelPlugin.js';
 
 class CohereGeneratePlugin extends ModelPlugin {
-    constructor(config, pathway, modelName, model) {
-        super(config, pathway, modelName, model);
+    constructor(pathway, model) {
+        super(pathway, model);
     }
 
     // Set up parameters specific to the Cohere API
@@ -33,17 +33,10 @@ class CohereGeneratePlugin extends ModelPlugin {
     }
 
     // Execute the request to the Cohere API
-    async execute(text, parameters, prompt, pathwayResolver) {
-        const url = this.requestUrl();
+    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 || {}
-        };
-        return this.executeRequest(url, data, params, headers, prompt, requestId, pathway);
+        cortexRequest.data = { ...cortexRequest.data, ...requestParameters };
+        return this.executeRequest(cortexRequest);
     }
 
     // Parse the response from the Cohere API

package/server/plugins/cohereSummarizePlugin.js

@@ -2,8 +2,8 @@
 import ModelPlugin from './modelPlugin.js';
 
 class CohereSummarizePlugin extends ModelPlugin {
-    constructor(config, pathway, modelName, model) {
-        super(config, pathway, modelName, model);
+    constructor(pathway, model) {
+        super(pathway, model);
     }
 
     // Set up parameters specific to the Cohere Summarize API
@@ -23,17 +23,10 @@ class CohereSummarizePlugin extends ModelPlugin {
     }
 
     // Execute the request to the Cohere Summarize API
-    async execute(text, parameters, prompt, pathwayResolver) {
-        const url = this.requestUrl();
+    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 || {}
-        };
-        return this.executeRequest(url, data, params, headers, prompt, requestId, pathway);
+        cortexRequest.data = { ...cortexRequest.data, ...requestParameters };
+        return this.executeRequest(cortexRequest);
     }
 
     // Parse the response from the Cohere Summarize API

package/server/plugins/localModelPlugin.js

@@ -5,8 +5,8 @@ import { encode } from 'gpt-3-encoder';
 import logger from '../../lib/logger.js';
 
 class LocalModelPlugin extends ModelPlugin {
-    constructor(config, pathway, modelName, model) {
-        super(config, pathway, modelName, model);
+    constructor(pathway, model) {
+        super(pathway, model);
     }
 
     // if the input starts with a chatML response, just return that
@@ -47,7 +47,7 @@ class LocalModelPlugin extends ModelPlugin {
         };
     }
 
-    async execute(text, parameters, prompt, _pathwayResolver) {
+    async execute(text, parameters, prompt, _cortexRequest) {
         const requestParameters = this.getRequestParameters(text, parameters, prompt);
         const { executablePath, args } = this.model;
         args.push("--prompt", requestParameters.prompt);

package/server/plugins/modelPlugin.js

@@ -1,18 +1,18 @@
 // ModelPlugin.js
 import HandleBars from '../../lib/handleBars.js';
-
-import { request } from '../../lib/request.js';
+import { executeRequest } from '../../lib/requestExecutor.js';
 import { encode } from 'gpt-3-encoder';
 import { getFirstNToken } from '../chunker.js';
 import logger, { obscureUrlParams } from '../../lib/logger.js';
+import { config } from '../../config.js';
 
 const DEFAULT_MAX_TOKENS = 4096;
 const DEFAULT_MAX_RETURN_TOKENS = 256;
 const DEFAULT_PROMPT_TOKEN_RATIO = 0.5;
 
 class ModelPlugin {
-    constructor(config, pathway, modelName, model) {
-        this.modelName = modelName;
+    constructor(pathway, model) {
+        this.modelName = model.name;
         this.model = model;
         this.config = config;
         this.environmentVariables = config.getEnv();
@@ -33,7 +33,6 @@ class ModelPlugin {
 
         this.requestCount = 0;
         this.lastRequestStartTime = new Date();
-        this.shouldCache = config.get('enableCache') && (pathway.enableCache || pathway.temperature == 0);
     }
 
     truncateMessagesToTargetLength(messages, targetTokenLength) {
@@ -220,14 +219,14 @@ class ModelPlugin {
     parseResponse(data) { return data; }
 
     // Default simple logging
-    logRequestStart(url, _data) {
+    logRequestStart() {
         this.requestCount++;
         this.lastRequestStartTime = new Date();
         const logMessage = `>>> [${this.requestId}: ${this.pathwayName}.${this.requestCount}] request`;
         const header = '>'.repeat(logMessage.length);
         logger.info(`${header}`);
         logger.info(`${logMessage}`);
-        logger.info(`>>> Making API request to ${obscureUrlParams(url)}`);
+        logger.info(`>>> Making API request to ${obscureUrlParams(this.url)}`);
     }
 
     logAIRequestFinished() {
@@ -257,15 +256,22 @@ class ModelPlugin {
         prompt && prompt.debugInfo && (prompt.debugInfo += `\n${JSON.stringify(data)}`);
     }
     
-    async executeRequest(url, data, params, headers, prompt, requestId, pathway) {
+    async executeRequest(cortexRequest) {
         try {
-            this.aiRequestStartTime = new Date();
+            const { url, data, pathway, requestId, prompt } = cortexRequest;
+            this.url = url;
             this.requestId = requestId;
-            this.logRequestStart(url, data);
-            const responseData = await request({ url, data, params, headers, cache: this.shouldCache }, this.modelName, this.requestId, pathway);
+            this.pathwayName = pathway.name;
+            this.pathwayPrompt = pathway.prompt;
+
+            cortexRequest.cache = config.get('enableCache') && (pathway.enableCache || pathway.temperature == 0);
+            this.logRequestStart();
+
+            const responseData = await executeRequest(cortexRequest);
             
             if (responseData.error) {
-                throw new Error(`An error was returned from the server: ${JSON.stringify(responseData.error)}`);
+                logger.error(`An error was returned from the server: ${JSON.stringify(responseData.error)}`);
+                throw responseData;
             }
         
             this.logRequestData(data, responseData, prompt);

package/server/plugins/openAiChatExtensionPlugin.js

@@ -2,8 +2,8 @@
 import OpenAIChatPlugin from './openAiChatPlugin.js';
 
 class OpenAIChatExtensionPlugin extends OpenAIChatPlugin {
-    constructor(config, pathway, modelName, model) {
-        super(config, pathway, modelName, model);
+    constructor(pathway, model) {
+        super(pathway, model);
         this.tool = '';
     }
 
@@ -47,9 +47,9 @@ class OpenAIChatExtensionPlugin extends OpenAIChatPlugin {
         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 
+    async execute(text, parameters, prompt, cortexRequest) {
+        const result = await super.execute(text, parameters, prompt, cortexRequest);
+        cortexRequest.pathwayResolver.tool = this.tool; // add tool info back 
         return result;
     }
 

package/server/plugins/openAiChatPlugin.js

@@ -4,8 +4,8 @@ import { encode } from 'gpt-3-encoder';
 import logger from '../../lib/logger.js';
 
 class OpenAIChatPlugin extends ModelPlugin {
-    constructor(config, pathway, modelName, model) {
-        super(config, pathway, modelName, model);
+    constructor(pathway, model) {
+        super(pathway, model);
     }
 
     // convert to OpenAI messages array format if necessary
@@ -76,16 +76,14 @@ class OpenAIChatPlugin extends ModelPlugin {
         return requestParameters;
     }
 
-    // Execute the request to the OpenAI Chat API
-    async execute(text, parameters, prompt, pathwayResolver) {
-        const url = this.requestUrl(text);
+    // Assemble and execute the request to the OpenAI Chat API
+    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 = {}; // query params
-        const headers = this.model.headers || {};
-        return this.executeRequest(url, data, params, headers, prompt, requestId, pathway);
+        cortexRequest.data = { ...(cortexRequest.data || {}), ...requestParameters };
+        cortexRequest.params = {}; // query params
+
+        return this.executeRequest(cortexRequest);
     }
 
     // Parse the response from the OpenAI Chat API

package/server/plugins/openAiCompletionPlugin.js

@@ -16,8 +16,8 @@ const truncatePromptIfNecessary = (text, textTokenCount, modelMaxTokenCount, tar
 }
 
 class OpenAICompletionPlugin extends ModelPlugin {
-    constructor(config, pathway, modelName, model) {
-        super(config, pathway, modelName, model);
+    constructor(pathway, model) {
+        super(pathway, model);
     }
 
     // Set up parameters specific to the OpenAI Completion API
@@ -76,16 +76,13 @@ class OpenAICompletionPlugin extends ModelPlugin {
     }
 
     // Execute the request to the OpenAI 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 = { ...(this.model.params || {}), ...requestParameters };
-        const params = {};
-        const headers = this.model.headers || {};
-        
-        return this.executeRequest(url, data, params, headers, prompt, requestId, pathway);
+    async execute(text, parameters, prompt, cortexRequest) {
+        const requestParameters = this.getRequestParameters(text, parameters, prompt, cortexRequest.pathwayResolver);
+
+        cortexRequest.data = { ...(cortexRequest.data || {}), ...requestParameters };
+        cortexRequest.params = {};
+
+        return this.executeRequest(cortexRequest);
     }
 
     // Parse the response from the OpenAI Completion API