@inductiv/node-red-openai-api 0.7.0 → 1.0.0

package/lib.js

@@ -1,3 +1,5 @@
+const { response } = require("express");
+
 let OpenaiApi = (function () {
   "use strict";
 
@@ -5,358 +7,389 @@ let OpenaiApi = (function () {
   const OpenAI = require("openai").OpenAI;
 
   class OpenaiApi {
-    async createChatCompletion(parameters) {
-      let node = parameters._node;
-      delete parameters._node;
-
-      const clientParams = {
-        apiKey: parameters.apiKey,
-        baseURL: parameters.apiBase,
-        organization: parameters.organization,
+    constructor(apiKey, baseURL, organization) {
+      this.clientParams = {
+        apiKey: apiKey,
+        baseURL: baseURL,
+        organization: organization,
       };
+    }
+
+    // Begin Vector Store File functions
+    async createVectorStoreFile(parameters) {
+      const openai = new OpenAI(this.clientParams);
+      const { vector_store_id, ...params } = parameters.msg.payload;
+      const response = await openai.beta.vectorStores.files.create(
+        vector_store_id,
+        params,
+      );
+
+      return response;
+    }
+
+    async listVectorStoreFiles(parameters) {
+      /* Returns a list of vector store files. */
 
-      const openai = new OpenAI(clientParams);
-      const response = await openai.chat.completions.create({
-        ...parameters.msg.payload,
-      });
+      const openai = new OpenAI(this.clientParams);
+      const { vector_store_id, ...params } = parameters.msg.payload;
+      const list = await openai.beta.vectorStores.files.list(
+        vector_store_id,
+        params,
+      );
+
+      return [...list.data];
+    }
+
+    async retrieveVectorStoreFile(parameters) {
+      /* Retrieves a vector store file. */
+
+      const openai = new OpenAI(this.clientParams);
+      const { vector_store_id, file_id } = parameters.msg.payload;
+      const response = openai.beta.vectorStores.files.retrieve(
+        vector_store_id,
+        file_id,
+      );
+
+      return response;
+    }
 
-      if (parameters.msg.payload.stream) {
-        node.status({
+    async deleteVectorStoreFile(parameters) {
+      /* Removes a file from the vector store. */
+
+      const openai = new OpenAI(this.clientParams);
+      const { vector_store_id, file_id, ...params } = parameters.msg.payload;
+      const response = openai.beta.vectorStores.files.del(
+        vector_store_id,
+        file_id,
+        params,
+      );
+
+      return response;
+    }
+
+    // End Vector Store File functions
+
+    async createVectorStoreFileBatch(parameters) {
+      const openai = new OpenAI(this.clientParams);
+      const { vector_store_id, ...params } = parameters.msg.payload;
+      const response = await openai.beta.vectorStores.fileBatches.create(
+        vector_store_id,
+        params,
+      );
+
+      return response;
+    }
+
+    async retrieveVectorStoreFileBatch(parameters) {
+      const openai = new OpenAI(this.clientParams);
+      const { vector_store_id, batch_id, ...params } = parameters.msg.payload;
+      const response = await openai.beta.vectorStores.fileBatches.retrieve(
+        vector_store_id,
+        batch_id,
+        params,
+      );
+
+      return response;
+    }
+
+    async cancelVectorStoreFileBatch(parameters) {
+      const openai = new OpenAI(this.clientParams);
+      const { vector_store_id, batch_id, ...params } = parameters.msg.payload;
+      const response = await openai.beta.vectorStores.fileBatches.retrieve(
+        vector_store_id,
+        batch_id,
+        params,
+      );
+
+      return response;
+    }
+
+    async listVectorStoreBatchFiles(parameters) {
+      const openai = new OpenAI(this.clientParams);
+      const { vector_store_id, batch_id, ...params } = parameters.msg.payload;
+      const list = await openai.beta.vectorStores.fileBatches.listFiles(
+        vector_store_id,
+        batch_id,
+        params,
+      );
+      const batchFiles = [...list.data];
+
+      return batchFiles;
+    }
+
+    async createVectorStore(parameters) {
+      const openai = new OpenAI(this.clientParams);
+      const response = await openai.beta.vectorStores.create(
+        parameters.msg.payload,
+      );
+
+      return response;
+    }
+
+    async listVectorStores(parameters) {
+      const openai = new OpenAI(this.clientParams);
+      const list = await openai.beta.vectorStores.list(parameters.msg.payload);
+      const vectorStores = [...list.data];
+
+      return vectorStores;
+    }
+
+    async retrieveVectorStore(parameters) {
+      const openai = new OpenAI(this.clientParams);
+      const { vector_store_id, ...params } = parameters.msg.payload;
+      const response = await openai.beta.vectorStores.retrieve(
+        vector_store_id,
+        params,
+      );
+
+      return response;
+    }
+
+    async modifyVectorStore(parameters) {
+      const openai = new OpenAI(this.clientParams);
+      const { vector_store_id, ...params } = parameters.msg.payload;
+      const response = await openai.beta.vectorStores.update(
+        vector_store_id,
+        params,
+      );
+
+      return response;
+    }
+
+    async deleteVectorStore(parameters) {
+      const openai = new OpenAI(this.clientParams);
+      const { vector_store_id, ...params } = parameters.msg.payload;
+      const response = await openai.beta.vectorStores.del(
+        vector_store_id,
+        params,
+      );
+
+      return response;
+    }
+
+    async createBatch(parameters) {
+      const openai = new OpenAI(this.clientParams);
+      const response = await openai.batches.create(parameters.msg.payload);
+
+      return response;
+    }
+
+    async retrieveBatch(parameters) {
+      const openai = new OpenAI(this.clientParams);
+      const { batch_id, ...params } = parameters.msg.payload;
+      const response = await openai.batches.retrieve(batch_id, params);
+
+      return response;
+    }
+
+    async listBatch(parameters) {
+      const openai = new OpenAI(this.clientParams);
+      const list = await openai.batches.list(parameters.msg.payload);
+      const batches = [...list.data];
+
+      return batches;
+    }
+
+    async cancelBatch(parameters) {
+      const openai = new OpenAI(this.clientParams);
+      const { batch_id, ...params } = parameters.msg.payload;
+      const response = await openai.batches.cancel(batch_id, params);
+
+      return response;
+    }
+
+    async createChatCompletion(parameters) {
+      const { _node, ...params } = parameters;
+      const openai = new OpenAI(this.clientParams);
+      const response = await openai.chat.completions.create(params.msg.payload);
+
+      if (params.msg.payload.stream) {
+        _node.status({
           fill: "green",
           shape: "dot",
           text: "OpenaiApi.status.streaming",
         });
         for await (const chunk of response) {
           if (typeof chunk === "object") {
-            let msg = parameters.msg;
-            msg.payload = chunk;
-            node.send(msg);
+            let { _msgid, ...newMsg } = parameters.msg;
+            newMsg.payload = chunk;
+
+            _node.send(newMsg);
           }
         }
-        node.status({});
+        _node.status({});
       } else {
         return response;
       }
     }
 
     async createImage(parameters) {
-      const clientParams = {
-        apiKey: parameters.apiKey,
-        baseURL: parameters.apiBase,
-        organization: parameters.organization,
-      };
-
-      const openai = new OpenAI(clientParams);
-      const response = await openai.images.generate({
-        ...parameters.msg.payload,
-      });
+      const openai = new OpenAI(this.clientParams);
+      const response = await openai.images.generate(parameters.msg.payload);
 
-      return response;
+      return response.data;
     }
 
     async createImageEdit(parameters) {
-      const clientParams = {
-        apiKey: parameters.apiKey,
-        baseURL: parameters.apiBase,
-        organization: parameters.organization,
-      };
-      const openai = new OpenAI(clientParams);
+      const openai = new OpenAI(this.clientParams);
+      let { image, mask, ...params } = parameters.msg.payload;
 
-      parameters.msg.payload.image = fs.createReadStream(
-        parameters.msg.payload.image,
-      );
-      if (parameters.msg.payload.mask) {
-        parameters.msg.payload.mask = fs.createReadStream(
-          parameters.msg.payload.mask,
-        );
+      params.image = fs.createReadStream(image);
+      if (mask) {
+        params.mask = fs.createReadStream(mask);
       }
+      const response = await openai.images.edit(params);
 
-      const response = await openai.images.edit({
-        ...parameters.msg.payload,
-      });
-
-      return response;
+      return response.data;
     }
 
     async createImageVariation(parameters) {
-      const clientParams = {
-        apiKey: parameters.apiKey,
-        baseURL: parameters.apiBase,
-        organization: parameters.organization,
-      };
-      const openai = new OpenAI(clientParams);
+      const openai = new OpenAI(this.clientParams);
+      let { image, ...params } = parameters.msg.payload;
 
-      parameters.msg.payload.image = fs.createReadStream(
-        parameters.msg.payload.image,
-      );
-      const response = await openai.images.createVariation({
-        ...parameters.msg.payload,
-      });
+      params.image = fs.createReadStream(image);
+      const response = await openai.images.createVariation(params);
 
-      return response;
+      return response.data;
     }
 
     async createEmbedding(parameters) {
-      const clientParams = {
-        apiKey: parameters.apiKey,
-        baseURL: parameters.apiBase,
-        organization: parameters.organization,
-      };
-      const openai = new OpenAI(clientParams);
+      const openai = new OpenAI(this.clientParams);
+      const response = await openai.embeddings.create(parameters.msg.payload);
 
-      const response = await openai.embeddings.create({
-        ...parameters.msg.payload,
-      });
-
-      return response;
+      return response.data;
     }
 
     async createSpeech(parameters) {
-      const clientParams = {
-        apiKey: parameters.apiKey,
-        baseURL: parameters.apiBase,
-        organization: parameters.organization,
-      };
-      const openai = new OpenAI(clientParams);
-
-      const audio = await openai.audio.speech.create({
-        ...parameters.msg.payload,
-      });
+      const openai = new OpenAI(this.clientParams);
+      const audio = await openai.audio.speech.create(parameters.msg.payload);
       const response = Buffer.from(await audio.arrayBuffer());
 
       return response;
     }
 
     async createTranscription(parameters) {
-      const clientParams = {
-        apiKey: parameters.apiKey,
-        baseURL: parameters.apiBase,
-        organization: parameters.organization,
-      };
-      const openai = new OpenAI(clientParams);
+      const openai = new OpenAI(this.clientParams);
+      let { file, ...params } = parameters.msg.payload;
 
-      parameters.msg.payload.file = fs.createReadStream(
-        parameters.msg.payload.file,
-      );
+      params.file = fs.createReadStream(file);
 
-      const response = await openai.audio.transcriptions.create({
-        ...parameters.msg.payload,
-      });
+      const response = await openai.audio.transcriptions.create(params);
 
       return response;
     }
 
     async createTranslation(parameters) {
-      const clientParams = {
-        apiKey: parameters.apiKey,
-        baseURL: parameters.apiBase,
-        organization: parameters.organization,
-      };
-      const openai = new OpenAI(clientParams);
+      const openai = new OpenAI(this.clientParams);
+      let { file, ...params } = parameters.msg.payload;
 
-      parameters.msg.payload.file = fs.createReadStream(
-        parameters.msg.payload.file,
-      );
-      const response = await openai.audio.translations.create({
-        ...parameters.msg.payload,
-      });
+      params.file = fs.createReadStream(file);
+
+      const response = await openai.audio.translations.create(params);
 
       return response;
     }
 
     async listFiles(parameters) {
-      const clientParams = {
-        apiKey: parameters.apiKey,
-        baseURL: parameters.apiBase,
-        organization: parameters.organization,
-      };
-      const openai = new OpenAI(clientParams);
+      const openai = new OpenAI(this.clientParams);
+      const list = await openai.files.list(parameters.msg.payload);
 
-      const list = await openai.files.list({
-        ...parameters.msg.payload,
-      });
-
-      let files = [];
-      for await (const file of list) {
-        files.push(file);
-      }
-
-      return files;
+      return [...list.data];
     }
 
     async createFile(parameters) {
-      const clientParams = {
-        apiKey: parameters.apiKey,
-        baseURL: parameters.apiBase,
-        organization: parameters.organization,
-      };
-      const openai = new OpenAI(clientParams);
+      const openai = new OpenAI(this.clientParams);
+      let { file, ...params } = parameters.msg.payload;
 
-      parameters.msg.payload.file = fs.createReadStream(
-        parameters.msg.payload.file,
-      );
-      const response = await openai.files.create({
-        ...parameters.msg.payload,
-      });
+      params.file = fs.createReadStream(file);
+
+      const response = await openai.files.create(params);
 
       return response;
     }
 
     async deleteFile(parameters) {
-      const clientParams = {
-        apiKey: parameters.apiKey,
-        baseURL: parameters.apiBase,
-        organization: parameters.organization,
-      };
-      const openai = new OpenAI(clientParams);
-
-      const response = await openai.files.del({
-        ...parameters.msg.payload,
-      });
+      const openai = new OpenAI(this.clientParams);
+      const { file_id, ...params } = parameters.msg.payload;
+      const response = await openai.files.del(file_id, params);
 
       return response;
     }
 
     async retrieveFile(parameters) {
-      const clientParams = {
-        apiKey: parameters.apiKey,
-        baseURL: parameters.apiBase,
-        organization: parameters.organization,
-      };
-      const openai = new OpenAI(clientParams);
-
-      const file_id = parameters.msg.payload.file_id;
-      delete parameters.msg.payload.file_id;
-
-      const response = await openai.files.retrieve(file_id, {
-        ...parameters.msg.payload,
-      });
+      const openai = new OpenAI(this.clientParams);
+      const { file_id, ...params } = parameters.msg.payload;
+      const response = await openai.files.retrieve(file_id, params);
 
       return response;
     }
 
     async downloadFile(parameters) {
-      const clientParams = {
-        apiKey: parameters.apiKey,
-        baseURL: parameters.apiBase,
-        organization: parameters.organization,
-      };
-      const openai = new OpenAI(clientParams);
-
-      const file_id = parameters.msg.payload.file_id;
-      delete parameters.msg.payload.file_id;
-
-      const response = await openai.files.retrieveContent(file_id, {
-        ...parameters.msg.payload,
-      });
+      const openai = new OpenAI(this.clientParams);
+      const { file_id, ...params } = parameters.msg.payload;
+      const response = await openai.files.content(file_id, params);
 
       return response;
     }
 
     async createFineTuningJob(parameters) {
-      const clientParams = {
-        apiKey: parameters.apiKey,
-        baseURL: parameters.apiBase,
-        organization: parameters.organization,
-      };
-      const openai = new OpenAI(clientParams);
-
-      const response = await openai.fineTuning.jobs.create({
-        ...parameters.msg.payload,
-      });
+      const openai = new OpenAI(this.clientParams);
+      const response = await openai.fineTuning.jobs.create(
+        parameters.msg.payload,
+      );
 
       return response;
     }
 
     async listPaginatedFineTuningJobs(parameters) {
-      const clientParams = {
-        apiKey: parameters.apiKey,
-        baseURL: parameters.apiBase,
-        organization: parameters.organization,
-      };
-      const openai = new OpenAI(clientParams);
-
-      const list = await openai.fineTuning.jobs.list({
-        ...parameters.msg.payload,
-      });
-
-      let response = [];
-      for await (const fineTune of list) {
-        response.push(fineTune);
-      }
+      const openai = new OpenAI(this.clientParams);
+      const list = await openai.fineTuning.jobs.list(parameters.msg.payload);
 
-      return response;
+      return [...list.data];
     }
 
     async retrieveFineTuningJob(parameters) {
-      const clientParams = {
-        apiKey: parameters.apiKey,
-        baseURL: parameters.apiBase,
-        organization: parameters.organization,
-      };
-      const openai = new OpenAI(clientParams);
-
+      const openai = new OpenAI(this.clientParams);
+      const { fine_tuning_job_id, ...params } = parameters.msg.payload;
       const response = await openai.fineTuning.jobs.retrieve(
-        parameters.msg.payload.fine_tuning_job_id,
+        fine_tuning_job_id,
+        params,
       );
 
       return response;
     }
 
     async listFineTuningEvents(parameters) {
-      const clientParams = {
-        apiKey: parameters.apiKey,
-        baseURL: parameters.apiBase,
-        organization: parameters.organization,
-      };
-      const openai = new OpenAI(clientParams);
-
-      let response = [];
+      const openai = new OpenAI(this.clientParams);
+      const { fine_tuning_job_id, ...params } = parameters.msg.payload;
       const list = await openai.fineTuning.jobs.listEvents(
-        parameters.msg.payload.fine_tuning_job_id,
+        fine_tuning_job_id,
+        params,
       );
-      for await (const fineTuneEvent of list) {
-        response.push(fineTuneEvent);
-      }
-      return response;
+
+      return [...list.data];
     }
 
     async cancelFineTuningJob(parameters) {
-      const clientParams = {
-        apiKey: parameters.apiKey,
-        baseURL: parameters.apiBase,
-        organization: parameters.organization,
-      };
-      const openai = new OpenAI(clientParams);
-
+      const openai = new OpenAI(this.clientParams);
+      const { fine_tuning_job_id, ...params } = parameters.msg.payload;
       const response = await openai.fineTuning.jobs.cancel(
-        parameters.msg.payload.fine_tuning_job_id,
+        fine_tuning_job_id,
+        params,
       );
 
       return response;
     }
 
     async listModels(parameters) {
-      const clientParams = {
-        apiKey: parameters.apiKey,
-        baseURL: parameters.apiBase,
-        organization: parameters.organization,
-      };
-      const openai = new OpenAI(clientParams);
-
-      const response = await openai.models.list();
+      const openai = new OpenAI(this.clientParams);
+      const list = await openai.models.list();
 
-      return response.body;
+      return [...list.data];
     }
 
     async retrieveModel(parameters) {
-      const clientParams = {
-        apiKey: parameters.apiKey,
-        baseURL: parameters.apiBase,
-        organization: parameters.organization,
-      };
-      const openai = new OpenAI(clientParams);
-
+      const openai = new OpenAI(this.clientParams);
       const model = parameters.msg.payload.model;
       const response = await openai.models.retrieve(model);
 
@@ -364,13 +397,7 @@ let OpenaiApi = (function () {
     }
 
     async deleteModel(parameters) {
-      const clientParams = {
-        apiKey: parameters.apiKey,
-        baseURL: parameters.apiBase,
-        organization: parameters.organization,
-      };
-      const openai = new OpenAI(clientParams);
-
+      const openai = new OpenAI(this.clientParams);
       const model = parameters.msg.payload.model;
       const response = await openai.models.del(model);
 
@@ -378,549 +405,277 @@ let OpenaiApi = (function () {
     }
 
     async createModeration(parameters) {
-      const clientParams = {
-        apiKey: parameters.apiKey,
-        baseURL: parameters.apiBase,
-        organization: parameters.organization,
-      };
-      const openai = new OpenAI(clientParams);
-
+      const openai = new OpenAI(this.clientParams);
       const response = await openai.moderations.create(parameters.msg.payload);
       return response;
     }
 
     async listAssistants(parameters) {
-      const clientParams = {
-        apiKey: parameters.apiKey,
-        baseURL: parameters.apiBase,
-        organization: parameters.organization,
-      };
-      const openai = new OpenAI(clientParams);
+      const openai = new OpenAI(this.clientParams);
+      const list = await openai.beta.assistants.list(parameters.msg.payload);
 
-      const response = await openai.beta.assistants.list({
-        ...parameters.msg.payload,
-      });
-
-      return response.body;
+      return [...list.data];
     }
 
     async createAssistant(parameters) {
-      const clientParams = {
-        apiKey: parameters.apiKey,
-        baseURL: parameters.apiBase,
-        organization: parameters.organization,
-      };
-      const openai = new OpenAI(clientParams);
-
-      const response = await openai.beta.assistants.create({
-        ...parameters.msg.payload,
-      });
+      const openai = new OpenAI(this.clientParams);
+      const response = await openai.beta.assistants.create(
+        parameters.msg.payload,
+      );
 
       return response;
     }
 
     async getAssistant(parameters) {
-      const clientParams = {
-        apiKey: parameters.apiKey,
-        baseURL: parameters.apiBase,
-        organization: parameters.organization,
-      };
-      const openai = new OpenAI(clientParams);
-
-      const id = parameters.msg.payload.assistant_id;
-      const response = await openai.beta.assistants.retrieve(id);
+      const openai = new OpenAI(this.clientParams);
+      const { assistant_id, ...params } = parameters.msg.payload;
+      const response = await openai.beta.assistants.retrieve(
+        assistant_id,
+        params,
+      );
 
       return response;
     }
 
     async modifyAssistant(parameters) {
-      const clientParams = {
-        apiKey: parameters.apiKey,
-        baseURL: parameters.apiBase,
-        organization: parameters.organization,
-      };
-      const openai = new OpenAI(clientParams);
-
-      const id = parameters.msg.payload.assistant_id;
-      delete parameters.msg.payload.assistant_id;
-
-      const response = await openai.beta.assistants.update(id, {
-        ...parameters.msg.payload,
-      });
+      const openai = new OpenAI(this.clientParams);
+      const { assistant_id, ...params } = parameters.msg.payload;
+      const response = await openai.beta.assistants.update(
+        assistant_id,
+        params,
+      );
 
       return response;
     }
 
     async deleteAssistant(parameters) {
-      const clientParams = {
-        apiKey: parameters.apiKey,
-        baseURL: parameters.apiBase,
-        organization: parameters.organization,
-      };
-      const openai = new OpenAI(clientParams);
-
-      const id = parameters.msg.payload.assistant_id;
-      const response = await openai.beta.assistants.del(id);
+      const openai = new OpenAI(this.clientParams);
+      const { assistant_id, ...params } = parameters.msg.payload;
+      const response = await openai.beta.assistants.del(assistant_id, params);
 
       return response;
     }
 
     async createThread(parameters) {
-      const clientParams = {
-        apiKey: parameters.apiKey,
-        baseURL: parameters.apiBase,
-        organization: parameters.organization,
-      };
-      const openai = new OpenAI(clientParams);
-
-      const response = await openai.beta.threads.create({
-        ...parameters.msg.payload,
-      });
+      const openai = new OpenAI(this.clientParams);
+      const response = await openai.beta.threads.create(parameters.msg.payload);
 
       return response;
     }
 
     async getThread(parameters) {
-      const clientParams = {
-        apiKey: parameters.apiKey,
-        baseURL: parameters.apiBase,
-        organization: parameters.organization,
-      };
-      const openai = new OpenAI(clientParams);
-
-      const id = parameters.msg.payload.thread_id;
-      const response = await openai.beta.threads.retrieve(id);
+      const openai = new OpenAI(this.clientParams);
+      const { thread_id, ...params } = parameters.msg.payload;
+      const response = await openai.beta.threads.retrieve(thread_id, params);
 
       return response;
     }
 
     async modifyThread(parameters) {
-      const clientParams = {
-        apiKey: parameters.apiKey,
-        baseURL: parameters.apiBase,
-        organization: parameters.organization,
-      };
-      const openai = new OpenAI(clientParams);
-
-      const id = parameters.msg.payload.thread_id;
-      delete parameters.msg.payload.thread_id;
-
-      const response = await openai.beta.threads.update(id, {
-        ...parameters.msg.payload,
-      });
+      const openai = new OpenAI(this.clientParams);
+      const { thread_id, ...params } = parameters.msg.payload;
+      const response = await openai.beta.threads.update(thread_id, params);
 
       return response;
     }
 
     async deleteThread(parameters) {
-      const clientParams = {
-        apiKey: parameters.apiKey,
-        baseURL: parameters.apiBase,
-        organization: parameters.organization,
-      };
-      const openai = new OpenAI(clientParams);
-
-      const id = parameters.msg.payload.thread_id;
-      const response = await openai.beta.threads.del(id);
+      const openai = new OpenAI(this.clientParams);
+      const { thread_id, ...params } = parameters.msg.payload;
+      const response = await openai.beta.threads.del(thread_id, params);
 
       return response;
     }
 
     async listMessages(parameters) {
-      const clientParams = {
-        apiKey: parameters.apiKey,
-        baseURL: parameters.apiBase,
-        organization: parameters.organization,
-      };
-      const openai = new OpenAI(clientParams);
-
-      const id = parameters.msg.payload.thread_id;
-      const response = await openai.beta.threads.messages.list(id);
+      const openai = new OpenAI(this.clientParams);
+      const { thread_id, ...params } = parameters.msg.payload;
+      const list = await openai.beta.threads.messages.list(thread_id, params);
 
-      return response.body;
+      return [...list.data];
     }
 
     async createMessage(parameters) {
-      const clientParams = {
-        apiKey: parameters.apiKey,
-        baseURL: parameters.apiBase,
-        organization: parameters.organization,
-      };
-      const openai = new OpenAI(clientParams);
-
-      const thread_id = parameters.msg.payload.thread_id;
-      delete parameters.msg.payload.thread_id;
-
-      const response = await openai.beta.threads.messages.create(thread_id, {
-        ...parameters.msg.payload,
-      });
+      const openai = new OpenAI(this.clientParams);
+      const { thread_id, ...params } = parameters.msg.payload;
+      const response = await openai.beta.threads.messages.create(
+        thread_id,
+        params,
+      );
 
       return response;
     }
 
     async getMessage(parameters) {
-      const clientParams = {
-        apiKey: parameters.apiKey,
-        baseURL: parameters.apiBase,
-        organization: parameters.organization,
-      };
-      const openai = new OpenAI(clientParams);
-
-      const thread_id = parameters.msg.payload.thread_id;
-      const message_id = parameters.msg.payload.message_id;
-
+      const openai = new OpenAI(this.clientParams);
+      const { thread_id, message_id, ...params } = parameters.msg.payload;
       const response = await openai.beta.threads.messages.retrieve(
         thread_id,
         message_id,
+        params,
       );
 
       return response;
     }
 
     async modifyMessage(parameters) {
-      const clientParams = {
-        apiKey: parameters.apiKey,
-        baseURL: parameters.apiBase,
-        organization: parameters.organization,
-      };
-      const openai = new OpenAI(clientParams);
-
-      const thread_id = parameters.msg.payload.thread_id;
-      const message_id = parameters.msg.payload.message_id;
-      delete parameters.msg.payload.thread_id;
-      delete parameters.msg.payload.message_id;
-
+      const openai = new OpenAI(this.clientParams);
+      const { thread_id, message_id, ...params } = parameters.msg.payload;
       const response = await openai.beta.threads.messages.update(
         thread_id,
         message_id,
-        {
-          ...parameters.msg.payload,
-        },
+        params,
       );
 
       return response;
     }
 
     async createThreadAndRun(parameters) {
-      const clientParams = {
-        apiKey: parameters.apiKey,
-        baseURL: parameters.apiBase,
-        organization: parameters.organization,
-      };
-      const openai = new OpenAI(clientParams);
+      const openai = new OpenAI(this.clientParams);
 
-      const response = await openai.beta.threads.createAndRun({
-        ...parameters.msg.payload,
-      });
+      const { _node, ...params } = parameters;
+      const response = await openai.beta.threads.createAndRun(
+        params.msg.payload,
+      );
 
-      return response;
+      if (params.msg.payload.stream) {
+        _node.status({
+          fill: "green",
+          shape: "dot",
+          text: "OpenaiApi.status.streaming",
+        });
+        for await (const chunk of response) {
+          if (typeof chunk === "object") {
+            let { _msgid, ...newMsg } = parameters.msg;
+            newMsg.payload = chunk.data;
+
+            _node.send(newMsg);
+          }
+        }
+        _node.status({});
+      } else {
+        return response;
+      }
     }
 
     async listRuns(parameters) {
-      const clientParams = {
-        apiKey: parameters.apiKey,
-        baseURL: parameters.apiBase,
-        organization: parameters.organization,
-      };
-      const openai = new OpenAI(clientParams);
-
-      const thred_id = parameters.msg.payload.thread_id;
-      delete parameters.msg.payload.thread_id;
-
-      const response = await openai.beta.threads.runs.list(thred_id, {
-        ...parameters.msg.payload,
-      });
+      const openai = new OpenAI(this.clientParams);
+      const { thread_id, ...params } = parameters.msg.payload;
+      const list = await openai.beta.threads.runs.list(thread_id, params);
 
-      return response.body;
+      return [...list.data];
     }
 
     async createRun(parameters) {
-      const clientParams = {
-        apiKey: parameters.apiKey,
-        baseURL: parameters.apiBase,
-        organization: parameters.organization,
-      };
-      const openai = new OpenAI(clientParams);
+      const openai = new OpenAI(this.clientParams);
 
-      const thread_id = parameters.msg.payload.thread_id;
-      delete parameters.msg.payload.thread_id;
+      const { _node, ..._params } = parameters;
+      const { thread_id, ...params } = _params.msg.payload;
+      const response = await openai.beta.threads.runs.create(thread_id, params);
 
-      const response = await openai.beta.threads.runs.create(thread_id, {
-        ...parameters.msg.payload,
-      });
+      if (params.stream) {
+        _node.status({
+          fill: "green",
+          shape: "dot",
+          text: "OpenaiApi.status.streaming",
+        });
+        for await (const chunk of response) {
+          if (typeof chunk === "object") {
+            let { _msgid, ...newMsg } = parameters.msg;
+            newMsg.payload = chunk.data;
 
-      return response;
+            _node.send(newMsg);
+          }
+        }
+        _node.status({});
+      } else {
+        return response;
+      }
     }
 
     async getRun(parameters) {
-      const clientParams = {
-        apiKey: parameters.apiKey,
-        baseURL: parameters.apiBase,
-        organization: parameters.organization,
-      };
-      const openai = new OpenAI(clientParams);
-
-      const thread_id = parameters.msg.payload.thread_id;
-      const run_id = parameters.msg.payload.run_id;
-      delete parameters.msg.payload.thread_id;
-      delete parameters.msg.payload.run_id;
-
+      const openai = new OpenAI(this.clientParams);
+      const { thread_id, run_id, ...params } = parameters.msg.payload;
       const response = await openai.beta.threads.runs.retrieve(
         thread_id,
         run_id,
+        params,
       );
 
       return response;
     }
 
     async modifyRun(parameters) {
-      const clientParams = {
-        apiKey: parameters.apiKey,
-        baseURL: parameters.apiBase,
-        organization: parameters.organization,
-      };
-      const openai = new OpenAI(clientParams);
-
-      const thread_id = parameters.msg.payload.thread_id;
-      const run_id = parameters.msg.payload.run_id;
-      delete parameters.msg.payload.thread_id;
-      delete parameters.msg.payload.run_id;
-
+      const openai = new OpenAI(this.clientParams);
+      const { thread_id, run_id, ...params } = parameters.msg.payload;
       const response = await openai.beta.threads.runs.update(
         thread_id,
         run_id,
-        {
-          ...parameters.msg.payload,
-        },
+        params,
       );
 
       return response;
     }
 
-    async submitToolOuputsToRun(parameters) {
-      const clientParams = {
-        apiKey: parameters.apiKey,
-        baseURL: parameters.apiBase,
-        organization: parameters.organization,
-      };
-      const openai = new OpenAI(clientParams);
-
-      const thread_id = parameters.msg.payload.thread_id;
-      const run_id = parameters.msg.payload.run_id;
-      delete parameters.msg.payload.thread_id;
-      delete parameters.msg.payload.run_id;
+    async submitToolOutputsToRun(parameters) {
+      const openai = new OpenAI(this.clientParams);
 
+      const {_node, ..._params} = parameters;
+      const { thread_id, run_id, ...params } = _params.msg.payload;
       const response = await openai.beta.threads.runs.submitToolOutputs(
         thread_id,
         run_id,
-        {
-          ...parameters.msg.payload,
-        },
+        params,
       );
 
-      return response;
+      if (params.stream) {
+        _node.status({
+          fill: "green",
+          shape: "dot",
+          text: "OpenaiApi.status.streaming",
+        });
+        for await (const chunk of response) {
+          if (typeof chunk === "object") {
+            let { _msgid, ...newMsg } = parameters.msg;
+            newMsg.payload = chunk.data;
+
+            _node.send(newMsg);
+          }
+        }
+        _node.status({});
+      } else {
+        return response;
+      }
     }
 
     async cancelRun(parameters) {
-      const clientParams = {
-        apiKey: parameters.apiKey,
-        baseURL: parameters.apiBase,
-        organization: parameters.organization,
-      };
-      const openai = new OpenAI(clientParams);
-
-      const thread_id = parameters.msg.payload.thread_id;
-      const run_id = parameters.msg.payload.run_id;
-      delete parameters.msg.payload.thread_id;
-      delete parameters.msg.payload.run_id;
-
+      const openai = new OpenAI(this.clientParams);
+      const { thread_id, run_id, ...params } = parameters.msg.payload;
       const response = await openai.beta.threads.runs.cancel(
         thread_id,
         run_id,
-        {
-          ...parameters.msg.payload,
-        },
+        params,
       );
 
       return response;
     }
 
     async listRunSteps(parameters) {
-      const clientParams = {
-        apiKey: parameters.apiKey,
-        baseURL: parameters.apiBase,
-        organization: parameters.organization,
-      };
-      const openai = new OpenAI(clientParams);
+      const openai = new OpenAI(this.clientParams);
+      const { thread_id, run_id, ...params } = parameters.msg.payload;
+      const list = await openai.beta.threads.runs.steps.list(run_id, params);
 
-      const thread_id = parameters.msg.payload.thread_id;
-      const run_id = parameters.msg.payload.run_id;
-      delete parameters.msg.payload.thread_id;
-      delete parameters.msg.payload.run_id;
-
-      const response = await openai.beta.threads.runs.steps.list(
-        thread_id,
-        run_id,
-        {
-          ...parameters.msg.payload,
-        },
-      );
-
-      return response.body;
+      return [...list.data];
     }
 
     async getRunStep(parameters) {
-      const clientParams = {
-        apiKey: parameters.apiKey,
-        baseURL: parameters.apiBase,
-        organization: parameters.organization,
-      };
-      const openai = new OpenAI(clientParams);
-
-      const thread_id = parameters.msg.payload.thread_id;
-      const run_id = parameters.msg.payload.run_id;
-      const step_id = parameters.msg.payload.step_id;
-
+      const openai = new OpenAI(this.clientParams);
+      const { thread_id, run_id, step_id, ...params } = parameters.msg.payload;
       const response = await openai.beta.threads.runs.steps.retrieve(
         thread_id,
         run_id,
         step_id,
-      );
-
-      return response;
-    }
-
-    async listAssistantFiles(parameters) {
-      const clientParams = {
-        apiKey: parameters.apiKey,
-        baseURL: parameters.apiBase,
-        organization: parameters.organization,
-      };
-      const openai = new OpenAI(clientParams);
-
-      const assistant_id = parameters.msg.payload.assistant_id;
-      delete parameters.msg.payload.assistant_id;
-
-      const response = await openai.beta.assistants.files.list(assistant_id, {
-        ...parameters.msg.payload,
-      });
-
-      return response.body;
-    }
-
-    async createAssistantFile(parameters) {
-      const clientParams = {
-        apiKey: parameters.apiKey,
-        baseURL: parameters.apiBase,
-        organization: parameters.organization,
-      };
-      const openai = new OpenAI(clientParams);
-
-      const assistant_id = parameters.msg.payload.assistant_id;
-      delete parameters.msg.payload.assistant_id;
-
-      const response = await openai.beta.assistants.files.create(assistant_id, {
-        ...parameters.msg.payload,
-      });
-
-      return response;
-    }
-
-    async getAssistantFile(parameters) {
-      const clientParams = {
-        apiKey: parameters.apiKey,
-        baseURL: parameters.apiBase,
-        organization: parameters.organization,
-      };
-      const openai = new OpenAI(clientParams);
-
-      const assistant_id = parameters.msg.payload.assistant_id;
-      const file_id = parameters.msg.payload.file_id;
-      delete parameters.msg.payload.assistant_id;
-      delete parameters.msg.payload.file_id;
-
-      const response = await openai.beta.assistants.files.retrieve(
-        assistant_id,
-        file_id,
-        {
-          ...parameters.msg.payload,
-        },
-      );
-
-      return response;
-    }
-
-    async deleteAssistantFile(parameters) {
-      const clientParams = {
-        apiKey: parameters.apiKey,
-        baseURL: parameters.apiBase,
-        organization: parameters.organization,
-      };
-      const openai = new OpenAI(clientParams);
-
-      const assistant_id = parameters.msg.payload.assistant_id;
-      const file_id = parameters.msg.payload.file_id;
-      delete parameters.msg.payload.assistant_id;
-      delete parameters.msg.payload.file_id;
-
-      const response = await openai.beta.assistants.files.del(
-        assistant_id,
-        file_id,
-        {
-          ...parameters.msg.payload,
-        },
-      );
-
-      return response;
-    }
-
-    async listMessageFiles(parameters) {
-      const clientParams = {
-        apiKey: parameters.apiKey,
-        baseURL: parameters.apiBase,
-        organization: parameters.organization,
-      };
-      const openai = new OpenAI(clientParams);
-
-      const thread_id = parameters.msg.payload.thread_id;
-      const message_id = parameters.msg.payload.message_id;
-      delete parameters.msg.payload.thread_id;
-      delete parameters.msg.payload.message_id;
-
-      const response = await openai.beta.threads.messages.files.list(
-        thread_id,
-        message_id,
-        {
-          ...parameters.msg.payload,
-        },
-      );
-
-      return response;
-    }
-
-    async getMessageFile(parameters) {
-      const clientParams = {
-        apiKey: parameters.apiKey,
-        baseURL: parameters.apiBase,
-        organization: parameters.organization,
-      };
-      const openai = new OpenAI(clientParams);
-
-      const thread_id = parameters.msg.payload.thread_id;
-      const message_id = parameters.msg.payload.message_id;
-      const file_id = parameters.msg.payload.file_id;
-
-      delete parameters.msg.payload.thread_id;
-      delete parameters.msg.payload.message_id;
-      delete parameters.msg.payload.file_id;
-
-      const response = await openai.beta.threads.messages.files.retrieve(
-        thread_id,
-        message_id,
-        file_id,
-        {
-          ...parameters.msg.payload,
-        },
+        params,
       );
 
       return response;