@aj-archipelago/cortex 1.1.3 → 1.1.4

package/lib/requestMonitor.js

@@ -1,43 +1,146 @@
+import { v4 as uuidv4 } from 'uuid';
+// eslint-disable-next-line import/no-extraneous-dependencies
+import { Deque } from '@datastructures-js/deque';
+
 class RequestMonitor {
-    constructor() {
-      this.callCount = 0;
+  constructor( callsToKeep = 10 ) {
+    this.callCount = new Deque();
+    this.peakCallRate = 0;
+    this.error429Count = new Deque();
+    this.errorCount = new Deque();
+    this.startTime = new Date();
+    this.callStartTimes = new Map();
+    this.callDurations = new Deque();
+    this.healthy = true;
+    this.ageOutTime = 5 * 60 * 1000; // 5 minutes
+    this.callsToKeep = callsToKeep;
+  }
+
+  get isHealthy() {
+    return this.healthy;
+  }
+
+  removeOldCallStats(dq, timeProperty) {
+    const currentTime = new Date();
+    while (!dq.isEmpty() && currentTime - (timeProperty ? dq.front()[timeProperty] : dq.front())  > this.ageOutTime) {
+      dq.popFront();
+    }
+  }
+  
+  maintain() {
+    this.removeOldCallStats(this.callCount);
+    if (this.callCount.size() === 0) {
       this.peakCallRate = 0;
-      this.error429Count = 0;
-      this.startTime = new Date();
     }
+    this.removeOldCallStats(this.callDurations, 'endTime');
+    this.removeOldCallStats(this.error429Count);
+    this.removeOldCallStats(this.errorCount);
   
-    incrementCallCount() {
-      this.callCount++;
-      if (this.getCallRate() > this.peakCallRate) {
-        this.peakCallRate = this.getCallRate();
+    if (this.getErrorRate() > 0.3) {
+      this.healthy = false;
+    } else {
+      this.healthy = true;
+    }
+  }
+
+  startCall() {
+    const callId = uuidv4();
+    const currentTime = new Date();
+    this.callStartTimes.set(callId, currentTime);
+    this.callCount.pushBack(currentTime);
+    this.maintain();
+    return callId;
+  }
+
+  endCall(callId) {
+    const endTime = new Date();
+    const startTime = this.callStartTimes.get(callId);
+
+    if (startTime) {
+      this.callStartTimes.delete(callId);
+      const callDuration = endTime - startTime;
+      this.callDurations.pushBack({endTime, callDuration});
+
+      // Keep the callDurations length to 5
+      while (this.callDurations.size() > this.callsToKeep) {
+        this.callDurations.popFront();
       }
     }
-  
-    incrementError429Count() {
-      this.error429Count++;
+
+    const callRate = this.getCallRate();
+    if (callRate > this.peakCallRate) {
+      this.peakCallRate = callRate;
     }
-  
-    getCallRate() {
-      const currentTime = new Date();
-      const timeElapsed = (currentTime - this.startTime) / 1000; // time elapsed in seconds
-      return timeElapsed < 1 ? this.callCount : this.callCount / timeElapsed;
+    
+    this.maintain();
+  }
+
+  getAverageCallDuration() {
+    this.maintain();
+    if (this.callDurations.size() === 0) {
+      return 0;
     }
+    const sum = this.callDurations.toArray().reduce((a, b) => a + b.callDuration, 0);
+    return sum / this.callDurations.size(); 
+  }
+
+  incrementError429Count() {
+    this.error429Count.pushBack(new Date());
+    this.maintain();
+  }
+
+  incrementErrorCount() {
+    this.errorCount.pushBack(new Date());
+    this.maintain();
+  }
+
+  getCallRate() {
+    this.maintain();
+    const currentTime = new Date();
+    const timeElapsed = (currentTime - this.callCount.front()) / 1000; // time elapsed in seconds]
+    return timeElapsed < 1 ? this.callCount.size() : this.callCount.size() / timeElapsed;
+  }
+
+  getPeakCallRate() {
+    this.maintain();
+    return this.peakCallRate;
+  }
 
-    getPeakCallRate() {
-      return this.peakCallRate;
+  getError429Rate() {
+    return this.callCount.size() ? this.error429Count.size() / this.callCount.size() : 0;
+  }
+
+  getErrorRate() {
+    return this.callCount.size() ? this.errorCount.size() / this.callCount.size() : 0;
+  }
+
+  calculatePercentComplete(callId) {
+    if (!this.callDurations.size()) {
+      return 0;
     }
   
-    getError429Rate() {
-      return this.error429Count / this.callCount;
-    }
+    const currentTime = new Date();
+    const duration = currentTime - this.callStartTimes.get(callId);
+    const average = this.getAverageCallDuration();
+    let percentComplete = duration / average;
   
-    reset() {
-      this.callCount = 0;
-      this.error429Count = 0;
-      this.peakCallRate = 0;
-      this.startTime = new Date();
+    if (percentComplete > 0.8) {
+      percentComplete = 0.8;
     }
+  
+    return percentComplete;
+  }
+
+  reset() {
+    this.callCount.clear();
+    this.peakCallRate = 0;
+    this.error429Count.clear();
+    this.errorCount.clear();
+    this.startTime = new Date();
+    this.callStartTimes = new Map();
+    this.callDurations.clear();
+    this.healthy = true;
   }
+}
 
-export default RequestMonitor;
-  
+export default RequestMonitor;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aj-archipelago/cortex",
-  "version": "1.1.3",
+  "version": "1.1.4",
   "description": "Cortex is a GraphQL API for AI. It provides a simple, extensible interface for using AI services from OpenAI, Azure and others.",
   "private": false,
   "repository": {
@@ -32,6 +32,7 @@
     "@apollo/server": "^4.7.3",
     "@apollo/server-plugin-response-cache": "^4.1.2",
     "@apollo/utils.keyvadapter": "^3.0.0",
+    "@datastructures-js/deque": "^1.0.4",
     "@graphql-tools/schema": "^9.0.12",
     "@keyv/redis": "^2.5.4",
     "axios": "^1.3.4",

package/pathways/summary.js

@@ -17,12 +17,12 @@ export default {
 
     // Custom resolver to generate summaries by reprompting if they are too long or too short.
     resolver: async (parent, args, contextValue, _info) => {
-        const { config, pathway, requestState } = contextValue;
+        const { config, pathway } = contextValue;
         const originalTargetLength = args.targetLength;
 
         // If targetLength is not provided, execute the prompt once and return the result.
         if (originalTargetLength === 0 || originalTargetLength === null) {
-            let pathwayResolver = new PathwayResolver({ config, pathway, args, requestState });
+            let pathwayResolver = new PathwayResolver({ config, pathway, args });
             return await pathwayResolver.resolve(args);
         }
 
@@ -37,7 +37,7 @@ export default {
 
         const MAX_ITERATIONS = 5;
         let summary = '';
-        let pathwayResolver = new PathwayResolver({ config, pathway, args, requestState });
+        let pathwayResolver = new PathwayResolver({ config, pathway, args });
 
         // Modify the prompt to be words-based instead of characters-based.
         pathwayResolver.pathwayPrompt = `Write a summary of all of the text below. If the text is in a language other than english, make sure the summary is written in the same language. Your summary should be ${targetWords} words in length.\n\nText:\n\n{{{text}}}\n\nSummary:\n\n`

package/server/graphql.js

@@ -16,7 +16,7 @@ import cors from 'cors';
 import { KeyvAdapter } from '@apollo/utils.keyvadapter';
 import responseCachePlugin from '@apollo/server-plugin-response-cache';
 import subscriptions from './subscriptions.js';
-import { buildLimiters } from '../lib/request.js';
+import { buildModelEndpoints } from '../lib/requestExecutor.js';
 import { cancelRequestResolver } from './resolver.js';
 import { buildPathways, buildModels } from '../config.js';
 import { requestState } from './requestState.js';
@@ -116,8 +116,8 @@ const build = async (config) => {
     await buildPathways(config);
     buildModels(config);
 
-    // build api limiters 
-    buildLimiters(config);
+    // build model API endpoints and limiters
+    buildModelEndpoints(config);
 
     //build api
     const pathways = config.get('pathways');
@@ -176,8 +176,8 @@ const build = async (config) => {
     });
 
     // If CORTEX_API_KEY is set, we roll our own auth middleware - usually not used if you're being fronted by a proxy
-    const cortexApiKey = config.get('cortexApiKey');
-    if (cortexApiKey) {
+    const cortexApiKeys = config.get('cortexApiKeys');
+    if (cortexApiKeys  && Array.isArray(cortexApiKeys)) {
         app.use((req, res, next) => {
             let providedApiKey = req.headers['cortex-api-key'] || req.query['cortex-api-key'];
             if (!providedApiKey) {
@@ -185,7 +185,7 @@ const build = async (config) => {
                 providedApiKey = providedApiKey?.startsWith('Bearer ') ? providedApiKey.slice(7) : providedApiKey;
             }
 
-            if (cortexApiKey && cortexApiKey !== providedApiKey) {
+            if (!cortexApiKeys.includes(providedApiKey)) {
                 if (req.baseUrl === '/graphql' || req.headers['content-type'] === 'application/graphql') {
                     res.status(401)
                     .set('WWW-Authenticate', 'Cortex-Api-Key')

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() {
@@ -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