@inductiv/node-red-openai-api 0.3.9 → 0.4.1

package/lib.js

@@ -1,788 +1,868 @@
-var OpenaiApi = (function () {
+let OpenaiApi = (function () {
   "use strict";
 
-  const axios = require("axios");
-  const FormData = require("form-data"); // Only if you handle form data
+  const fs = require("fs");
+  const OpenAI = require("openai").OpenAI;
 
   class OpenaiApi {
-    constructor(options) {
-      this.apiKey =
-        typeof options === "object"
-          ? options.apiKey
-            ? options.apiKey
-            : {}
-          : {};
-    }
+    async createChatCompletion(parameters) {
+      let node = parameters._node;
+      delete parameters._node;
+
+      const clientParams = {
+        apiKey: parameters.apiKey,
+        baseURL: parameters.apiBase,
+        organization: parameters.organization,
+      }
 
-    setApiKey(value, headerOrQueryName, isQuery) {
-      this.apiKey.value = value;
-      this.apiKey.headerOrQueryName = headerOrQueryName;
-      this.apiKey.isQuery = isQuery;
-    }
-    setApiBase(apiBase) {
-      this.domain = apiBase;
-    }
+      const openai = new OpenAI(clientParams);
+      const response = await openai.chat.completions.create({
+        ...parameters.payload,
+      });
 
-    setOrganizationIdHeader(organizationId) {
-      this.organizationId = organizationId;
+      if (parameters.payload.stream) {
+        for await (const chunk of response) {
+          node.send(chunk);
+        }
+        return { code: 0, status: "complete" };
+      } else {
+        return response;
+      }
     }
 
-    setAuthHeaders(headerParams) {
-      var headers = headerParams ? headerParams : {};
-      if (!this.apiKey.isQuery && this.apiKey.headerOrQueryName) {
-        headers[this.apiKey.headerOrQueryName] = `Bearer ${this.apiKey.value}`;
+    async createImage(parameters) {
+
+      const clientParams = {
+        apiKey: parameters.apiKey,
+        baseURL: parameters.apiBase,
+        organization: parameters.organization,
       }
-      return headers;
-    }
 
-    setNodeRef(node) {
-      this.node = node;
-    }
+      const openai = new OpenAI(clientParams);
+      const response = await openai.images.generate({
+        ...parameters.payload,
+      });
 
-    getFromEndpoint(path, parameters, expectedQueryParams, customHeaders = {}) {
-      return new Promise((resolve, reject) => {
-        var domain = this.domain;
-        var organizationId = this.organizationId;
-        var queryParameters = {};
-        var baseHeaders = {};
+      return response;
+    }
 
-        baseHeaders = this.setAuthHeaders(headers);
-        baseHeaders["Accept"] = "application/json";
-        if (organizationId) {
-          customHeaders["OpenAI-Organization"] = organizationId;
-        }
+    async createImageEdit(parameters) {
+      const clientParams = {
+        apiKey: parameters.apiKey,
+        baseURL: parameters.apiBase,
+        organization: parameters.organization,
+      }
+      const openai = new OpenAI(clientParams);
 
-        var headers = {
-          ...baseHeaders,
-          ...customHeaders,
-        };
-
-        // Only add query parameters if they are expected and exist
-        if (expectedQueryParams) {
-          expectedQueryParams.forEach((param) => {
-            if (parameters.body[param] !== undefined) {
-              queryParameters[param] = parameters.body[param];
-            }
-          });
-        }
+      parameters.payload.image = fs.createReadStream(parameters.payload.image);
+      if (parameters.payload.mask) {
+        parameters.payload.mask = fs.createReadStream(parameters.payload.mask);
+      }
 
-        // Merge any additional query parameters from the parameters object
-        queryParameters = mergeQueryParams(parameters, queryParameters);
-
-        // Axios request configuration
-        const config = {
-          method: "GET",
-          url: domain + path,
-          headers: headers,
-          params: queryParameters,
-        };
-
-        // Axios GET request
-        axios(config)
-          .then((response) => {
-            resolve(response);
-          })
-          .catch((error) => {
-            reject(error);
-          });
+      const response = await openai.images.edit({
+        ...parameters.payload,
       });
+
+      return response;
     }
 
-    postToEndpoint(
-      path,
-      parameters,
-      expectedQueryParams,
-      contentType,
-      filePath,
-      customHeaders = {},
-    ) {
-      return new Promise((resolve, reject) => {
-        const _path = require("path");
-
-        parameters = parameters || {};
-        var domain = this.domain;
-        var organizationId = this.organizationId;
-        var queryParameters = {},
-          baseHeaders = {},
-          data;
-
-        baseHeaders = this.setAuthHeaders(baseHeaders);
-        baseHeaders["Accept"] = "application/json";
-
-        if (organizationId) {
-          customHeaders["OpenAI-Organization"] = organizationId;
-        }
+    async createImageVariation(parameters) {
+      const clientParams = {
+        apiKey: parameters.apiKey,
+        baseURL: parameters.apiBase,
+        organization: parameters.organization,
+      }
+      const openai = new OpenAI(clientParams);
 
-        var headers = {
-          ...baseHeaders,
-          ...customHeaders,
-        };
-
-        // Determine the Content-Type
-        if (contentType === "form-data") {
-          var formData = new FormData();
-
-          Object.entries(parameters.body).forEach(([key, value]) => {
-            if (value instanceof Buffer) {
-              if (!filePath) {
-                throw new Error(
-                  "msg.payload must include a `filename` property.",
-                );
-              }
-
-              const filename = _path.basename(filePath);
-              formData.append(key, value, filename);
-            } else {
-              if (parameters.body[key] !== undefined) {
-                formData.append(key, value);
-              }
-            }
-          });
-
-          data = formData;
-
-          let formHeaders = formData.getHeaders();
-          Object.assign(headers, formHeaders);
-        } else {
-          // Handle JSON payloads
-          headers["Content-Type"] = "application/json";
-          data = parameters.body || {};
-        }
+      parameters.payload.image = fs.createReadStream(parameters.payload.image);
+      const response = await openai.images.createVariation({
+        ...parameters.payload,
+      });
 
-        // Add expected query parameters to the queryParameters object
-        if (expectedQueryParams) {
-          expectedQueryParams.forEach((param) => {
-            if (parameters.body[param] !== undefined) {
-              queryParameters[param] = parameters.body[param];
-            }
-          });
-        }
+      return response;
+    }
+
+    async createEmbedding(parameters) {
+      const clientParams = {
+        apiKey: parameters.apiKey,
+        baseURL: parameters.apiBase,
+        organization: parameters.organization,
+      }
+      const openai = new OpenAI(clientParams);
 
-        // Merge any additional query parameters from the parameters object
-        queryParameters = mergeQueryParams(parameters.body, queryParameters);
-
-        // Axios request configuration
-        const config = {
-          method: "POST",
-          url: domain + path,
-          headers: headers,
-          params: queryParameters,
-          data: data,
-          responseType: data.stream === true ? "stream" : "json",
-        };
-
-        axios(config)
-          .then((response) => {
-            if (config.responseType === "stream") {
-              // Handle the stream response
-              response.data
-                .on("data", (chunk) => {
-                  // Convert chunk from Uint8Array to string
-                  const chunkAsString = new TextDecoder().decode(chunk);
-
-                  // Emit converted data chunks as Node-RED messages
-                  this.node.send({ payload: chunkAsString });
-                })
-                .on("end", () => {
-                  // Handle the end of the stream
-                  resolve({ payload: "Stream ended" });
-                })
-                .on("error", (err) => {
-                  // Handle any errors
-                  reject(err);
-                });
-            } else {
-              // Handle non-stream response (e.g., JSON)
-              resolve(response);
-            }
-          })
-          .catch((error) => {
-            reject(error);
-          });
+      const response = await openai.embeddings.create({
+        ...parameters.payload,
       });
+
+      return response;
     }
 
-    deleteFromEndpoint(
-      path,
-      parameters,
-      expectedQueryParams,
-      customHeaders = {},
-    ) {
-      return new Promise((resolve, reject) => {
-        parameters = parameters || {};
-        var domain = this.domain;
-        var organizationId = this.organizationId;
-        var queryParameters = {},
-          baseHeaders = {};
-
-        baseHeaders = this.setAuthHeaders(headers);
-        baseHeaders["Accept"] = "application/json";
-
-        if (organizationId) {
-          customHeaders["OpenAI-Organization"] = organizationId;
-        }
+    async createSpeech(parameters) {
+      const clientParams = {
+        apiKey: parameters.apiKey,
+        baseURL: parameters.apiBase,
+        organization: parameters.organization,
+      }
+      const openai = new OpenAI(clientParams);
 
-        var headers = {
-          ...baseHeaders,
-          ...customHeaders,
-        };
-
-        // Only add query parameters if they are expected and exist
-        if (expectedQueryParams) {
-          expectedQueryParams.forEach((param) => {
-            if (parameters[param] !== undefined) {
-              queryParameters[param] = parameters.body[param];
-            }
-          });
-        }
+      const audio = await openai.audio.speech.create({ ...parameters.payload });
+      const response = Buffer.from(await audio.arrayBuffer());
 
-        // Merge any additional query parameters from the parameters object
-        queryParameters = mergeQueryParams(parameters, queryParameters);
-
-        // Axios request configuration
-        const config = {
-          method: "DELETE",
-          url: domain + path,
-          headers: headers,
-          params: queryParameters,
-        };
-
-        // Axios DELETE request
-        axios(config)
-          .then((response) => {
-            resolve(response);
-          })
-          .catch((error) => {
-            reject(error);
-          });
-      });
+      return response;
     }
 
-    createChatCompletion(parameters) {
-      const response = this.postToEndpoint("/chat/completions", parameters);
+    async createTranscription(parameters) {
+      const clientParams = {
+        apiKey: parameters.apiKey,
+        baseURL: parameters.apiBase,
+        organization: parameters.organization,
+      }
+      const openai = new OpenAI(clientParams);
+
+      parameters.payload.file = fs.createReadStream(parameters.payload.file);
+
+      const response = await openai.audio.transcriptions.create({
+        ...parameters.payload,
+      });
+
       return response;
     }
-    createImage(parameters) {
-      return this.postToEndpoint("/images/generations", parameters);
-    }
-    createImageEdit(parameters) {
-      const filename = parameters.body.filename;
-      delete parameters.body.filename;
 
-      return this.postToEndpoint(
-        "/images/edits",
-        parameters,
-        null,
-        "form-data",
-        filename,
-      );
-    }
-    createImageVariation(parameters) {
-      const filename = parameters.body.filename;
-      delete parameters.body.filename;
+    async createTranslation(parameters) {
+      const clientParams = {
+        apiKey: parameters.apiKey,
+        baseURL: parameters.apiBase,
+        organization: parameters.organization,
+      }
+      const openai = new OpenAI(clientParams);
 
-      return this.postToEndpoint(
-        "/images/variations",
-        parameters,
-        null,
-        "form-data",
-        filename,
-      );
+      parameters.payload.file = fs.createReadStream(parameters.payload.file);
+      const response = await openai.audio.translations.create({
+        ...parameters.payload,
+      });
+
+      return response;
     }
-    createEmbedding(parameters) {
-      return this.postToEndpoint("/embeddings", parameters);
+
+    async listFiles(parameters) {
+      const clientParams = {
+        apiKey: parameters.apiKey,
+        baseURL: parameters.apiBase,
+        organization: parameters.organization,
+      }
+      const openai = new OpenAI(clientParams);
+
+      const list = await openai.files.list({
+        ...parameters.payload,
+      });
+
+      let files = [];
+      for await (const file of list) {
+        files.push(file);
+      }
+
+      return files;
     }
-    createSpeech(parameters) {
-      return this.postToEndpoint("/audio/speech", parameters);
+
+    async createFile(parameters) {
+      const clientParams = {
+        apiKey: parameters.apiKey,
+        baseURL: parameters.apiBase,
+        organization: parameters.organization,
+      }
+      const openai = new OpenAI(clientParams);
+
+      parameters.payload.file = fs.createReadStream(parameters.payload.file);
+      const response = await openai.files.create({
+        ...parameters.payload,
+      });
+
+      return response;
     }
-    createTranscription(parameters) {
-      const filename = parameters.body.filename;
-      delete parameters.body.filename;
+    async deleteFile(parameters) {
+      const clientParams = {
+        apiKey: parameters.apiKey,
+        baseURL: parameters.apiBase,
+        organization: parameters.organization,
+      }
+      const openai = new OpenAI(clientParams);
 
-      return this.postToEndpoint(
-        "/audio/transcriptions",
-        parameters,
-        null,
-        "form-data",
-        filename,
-      );
+      const response = await openai.files.del({
+        ...parameters.payload,
+      });
+
+      return response;
     }
-    createTranslation(parameters) {
-      const filename = parameters.body.filename;
-      delete parameters.body.filename;
+    async retrieveFile(parameters) {
+      const clientParams = {
+        apiKey: parameters.apiKey,
+        baseURL: parameters.apiBase,
+        organization: parameters.organization,
+      }
+      const openai = new OpenAI(clientParams);
 
-      return this.postToEndpoint(
-        "/audio/translations",
-        parameters,
-        null,
-        "form-data",
-        filename,
-      );
+      const file_id = parameters.payload.file_id;
+      delete parameters.payload.file_id;
+
+      const response = await openai.files.retrieve(file_id, {
+        ...parameters.payload,
+      });
+
+      return response;
     }
-    listFiles(parameters) {
-      const expectedQueryParameters = ["purpose"];
-      return this.getFromEndpoint(
-        "/files",
-        parameters,
-        expectedQueryParameters,
-      );
+    async downloadFile(parameters) {
+      const clientParams = {
+        apiKey: parameters.apiKey,
+        baseURL: parameters.apiBase,
+        organization: parameters.organization,
+      }
+      const openai = new OpenAI(clientParams);
+
+      const file_id = parameters.payload.file_id;
+      delete parameters.payload.file_id;
+
+      const response = await openai.files.retrieveContent(file_id, {
+        ...parameters.payload,
+      });
+
+      return response;
     }
-    createFile(parameters) {
-      let filename;
+    async createFineTuningJob(parameters) {
+      const clientParams = {
+        apiKey: parameters.apiKey,
+        baseURL: parameters.apiBase,
+        organization: parameters.organization,
+      }
+      const openai = new OpenAI(clientParams);
 
-      // reference the incoming filename
-      filename = parameters.body.filename;
-      delete parameters.body.filename;
+      const response = await openai.fineTuning.jobs.create({
+        ...parameters.payload,
+      });
 
-      return this.postToEndpoint(
-        "/files",
-        parameters,
-        null,
-        "form-data",
-        filename,
-      );
+      return response;
     }
-    deleteFile(parameters) {
-      const file_id = parameters.body.file_id;
-      delete parameters.body.file_id;
-      return this.deleteFromEndpoint(`/files/${file_id}`, parameters);
-    }
-    retrieveFile(parameters) {
-      const file_id = parameters.body.file_id;
-      delete parameters.body.file_id;
-      return this.getFromEndpoint(`/files/${file_id}`, parameters);
-    }
-    downloadFile(parameters) {
-      const file_id = parameters.body.file_id;
-      delete parameters.body.file_id;
-      return this.getFromEndpoint(`/files/${file_id}/content`, parameters);
-    }
-    createFineTuningJob(parameters) {
-      return this.postToEndpoint("/fine_tuning/jobs", parameters);
-    }
-    listPaginatedFineTuningJobs(parameters) {
-      const expectedQueryParameters = ["after", "limit"];
-      return this.getFromEndpoint(
-        "/fine_tuning/jobs",
-        parameters,
-        expectedQueryParameters,
-      );
+    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.payload,
+      });
+
+      let response = [];
+      for await (const fineTune of list) {
+        response.push(fineTune);
+      }
+
+      return response;
     }
-    retrieveFineTuningJob(parameters) {
-      const fine_tuning_job_id = parameters.body.fine_tuning_job_id;
-      delete parameters.body.fine_tuning_job_id;
-      return this.getFromEndpoint(
-        `/fine_tuning/jobs/${fine_tuning_job_id}`,
-        parameters,
+    async retrieveFineTuningJob(parameters) {
+      const clientParams = {
+        apiKey: parameters.apiKey,
+        baseURL: parameters.apiBase,
+        organization: parameters.organization,
+      }
+      const openai = new OpenAI(clientParams);
+
+      const response = await openai.fineTuning.jobs.retrieve(
+        parameters.payload.fine_tuning_job_id,
       );
+
+      return response;
     }
-    listFineTuningEvents(parameters) {
-      const expectedQueryParameters = ["after", "limit"];
-      const fine_tuning_job_id = parameters.body.fine_tuning_job_id;
-      delete parameters.body.fine_tuning_job_id;
+    async listFineTuningEvents(parameters) {
+      const clientParams = {
+        apiKey: parameters.apiKey,
+        baseURL: parameters.apiBase,
+        organization: parameters.organization,
+      }
+      const openai = new OpenAI(clientParams);
 
-      return this.getFromEndpoint(
-        `/fine_tuning/jobs/${fine_tuning_job_id}/events`,
-        parameters,
-        expectedQueryParameters,
+      let response = [];
+      const list = await openai.fineTuning.jobs.listEvents(
+        parameters.payload.fine_tuning_job_id,
       );
+      for await (const fineTuneEvent of list) {
+        response.push(fineTuneEvent);
+      }
+      return response;
     }
-    cancelFineTuningJob(parameters) {
-      const fine_tuning_job_id = parameters.body.fine_tuning_job_id;
-      delete parameters.body.fine_tuning_job_id;
-      return this.postToEndpoint(
-        `/fine_tuning/jobs/${fine_tuning_job_id}/cancel`,
-        parameters,
+    async cancelFineTuningJob(parameters) {
+      const clientParams = {
+        apiKey: parameters.apiKey,
+        baseURL: parameters.apiBase,
+        organization: parameters.organization,
+      }
+      const openai = new OpenAI(clientParams);
+
+      const response = await openai.fineTuning.jobs.cancel(
+        parameters.payload.fine_tuning_job_id,
       );
+
+      return response;
     }
-    listModels(parameters) {
-      return this.getFromEndpoint("/models", parameters);
+    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();
+
+      return response.body;
     }
-    retrieveModel(parameters) {
-      const model = parameters.body.model;
-      delete parameters.body.model;
-      return this.getFromEndpoint(`/models/${model}`, parameters);
+    async retrieveModel(parameters) {
+      const clientParams = {
+        apiKey: parameters.apiKey,
+        baseURL: parameters.apiBase,
+        organization: parameters.organization,
+      }
+      const openai = new OpenAI(clientParams);
+
+      const model = parameters.payload.model;
+      const response = await openai.models.retrieve(model);
+
+      return response;
     }
-    deleteModel(parameters) {
-      const model = parameters.body.model;
-      delete parameters.body.model;
-      return this.deleteFromEndpoint(`/models/${model}`, parameters);
+    async deleteModel(parameters) {
+      const clientParams = {
+        apiKey: parameters.apiKey,
+        baseURL: parameters.apiBase,
+        organization: parameters.organization,
+      }
+      const openai = new OpenAI(clientParams);
+
+      const model = parameters.payload.model;
+      const response = await openai.models.del(model);
+
+      return response;
     }
-    createModeration(parameters) {
-      return this.postToEndpoint("/moderations", parameters);
+    async createModeration(parameters) {
+      const clientParams = {
+        apiKey: parameters.apiKey,
+        baseURL: parameters.apiBase,
+        organization: parameters.organization,
+      }
+      const openai = new OpenAI(clientParams);
+
+      const response = await openai.moderations.create(parameters.payload);
+      return response;
     }
-    listAssistants(parameters) {
-      const expectedQueryParameters = ["limit", "order", "after", "before"];
-      const customHeaders = { "OpenAI-Beta": "assistants=v1" };
+    async listAssistants(parameters) {
+      const clientParams = {
+        apiKey: parameters.apiKey,
+        baseURL: parameters.apiBase,
+        organization: parameters.organization,
+      }
+      const openai = new OpenAI(clientParams);
 
-      return this.getFromEndpoint(
-        "/assistants",
-        parameters,
-        expectedQueryParameters,
-        customHeaders,
-      );
+      const response = await openai.beta.assistants.list({
+        ...parameters.payload,
+      });
+
+      return response.body;
     }
-    createAssistant(parameters) {
-      var customHeaders = { "OpenAI-Beta": "assistants=v1" };
+    async createAssistant(parameters) {
+      const clientParams = {
+        apiKey: parameters.apiKey,
+        baseURL: parameters.apiBase,
+        organization: parameters.organization,
+      }
+      const openai = new OpenAI(clientParams);
 
-      return this.postToEndpoint(
-        "/assistants",
-        parameters,
-        null,
-        null,
-        null,
-        customHeaders,
-      );
+      const response = await openai.beta.assistants.create({
+        ...parameters.payload,
+      });
+
+      return response;
     }
-    getAssistant(parameters) {
-      const assistantId = parameters.body.assistant_id;
-      const customHeaders = { "OpenAI-Beta": "assistants=v1" };
-      delete parameters.body.assistant_id;
-      return this.getFromEndpoint(
-        `/assistants/${assistantId}`,
-        parameters,
-        null,
-        customHeaders,
-      );
+    async getAssistant(parameters) {
+      const clientParams = {
+        apiKey: parameters.apiKey,
+        baseURL: parameters.apiBase,
+        organization: parameters.organization,
+      }
+      const openai = new OpenAI(clientParams);
+
+      const id = parameters.payload.assistant_id;
+      const response = await openai.beta.assistants.retrieve(id);
+
+      return response;
     }
-    modifyAssistant(parameters) {
-      const assistant_id = parameters.body.assistant_id;
-      const customHeaders = { "OpenAI-Beta": "assistants=v1" };
-      delete parameters.body.assistant_id;
-      return this.postToEndpoint(
-        `/assistants/${assistant_id}`,
-        parameters,
-        null,
-        null,
-        null,
-        customHeaders,
-      );
+    async modifyAssistant(parameters) {
+      const clientParams = {
+        apiKey: parameters.apiKey,
+        baseURL: parameters.apiBase,
+        organization: parameters.organization,
+      }
+      const openai = new OpenAI(clientParams);
+
+      const id = parameters.payload.assistant_id;
+      delete parameters.payload.assistant_id;
+
+      const response = await openai.beta.assistants.update(id, {
+        ...parameters.payload,
+      });
+
+      return response;
     }
-    deleteAssistant(parameters) {
-      const assistant_id = parameters.body.assistant_id;
-      const customHeaders = { "OpenAI-Beta": "assistants=v1" };
-      delete parameters.body.assistant_id;
-      return this.deleteFromEndpoint(
-        `/assistants/${assistant_id}`,
-        parameters,
-        null,
-        customHeaders,
-      );
+    async deleteAssistant(parameters) {
+      const clientParams = {
+        apiKey: parameters.apiKey,
+        baseURL: parameters.apiBase,
+        organization: parameters.organization,
+      }
+      const openai = new OpenAI(clientParams);
+
+      const id = parameters.payload.assistant_id;
+      const response = await openai.beta.assistants.del(id);
+
+      return response;
     }
-    createThread(parameters) {
-      const customHeaders = { "OpenAI-Beta": "assistants=v1" };
-      return this.postToEndpoint(
-        "/threads",
-        parameters,
-        null,
-        null,
-        null,
-        customHeaders,
-      );
+    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.payload,
+      });
+
+      return response;
     }
-    getThread(parameters) {
-      const threadId = parameters.body.thread_id;
-      const customHeaders = { "OpenAI-Beta": "assistants=v1" };
-      delete parameters.body.thread_id;
-      return this.getFromEndpoint(
-        `/threads/${threadId}`,
-        parameters,
-        null,
-        customHeaders,
-      );
+    async getThread(parameters) {
+      const clientParams = {
+        apiKey: parameters.apiKey,
+        baseURL: parameters.apiBase,
+        organization: parameters.organization,
+      }
+      const openai = new OpenAI(clientParams);
+
+      const id = parameters.payload.thread_id;
+      const response = await openai.beta.threads.retrieve(id);
+
+      return response;
     }
-    modifyThread(parameters) {
-      const threadId = parameters.body.thread_id;
-      const customHeaders = { "OpenAI-Beta": "assistants=v1" };
-      delete parameters.body.thread_id;
-      return this.postToEndpoint(
-        `/threads/${threadId}`,
-        parameters,
-        null,
-        null,
-        null,
-        customHeaders,
-      );
+    async modifyThread(parameters) {
+      const clientParams = {
+        apiKey: parameters.apiKey,
+        baseURL: parameters.apiBase,
+        organization: parameters.organization,
+      }
+      const openai = new OpenAI(clientParams);
+
+      const id = parameters.payload.thread_id;
+      delete parameters.payload.thread_id;
+
+      const response = await openai.beta.threads.update(id, {
+        ...parameters.payload,
+      });
+
+      return response;
     }
-    deleteThread(parameters) {
-      const threadId = parameters.body.thread_id;
-      const customHeaders = { "OpenAI-Beta": "assistants=v1" };
-      delete parameters.body.thread_id;
-      return this.deleteFromEndpoint(
-        `/threads/${threadId}`,
-        parameters,
-        null,
-        customHeaders,
-      );
+    async deleteThread(parameters) {
+      const clientParams = {
+        apiKey: parameters.apiKey,
+        baseURL: parameters.apiBase,
+        organization: parameters.organization,
+      }
+      const openai = new OpenAI(clientParams);
+
+      const id = parameters.payload.thread_id;
+      const response = await openai.beta.threads.del(id);
+
+      return response;
     }
-    listMessages(parameters) {
-      const threadId = parameters.body.thread_id;
-      const customHeaders = { "OpenAI-Beta": "assistants=v1" };
-      const expectedQueryParameters = ["limit", "order", "after", "before"];
-      delete parameters.body.thread_id;
-      return this.getFromEndpoint(
-        `/threads/${threadId}/messages`,
-        parameters,
-        expectedQueryParameters,
-        customHeaders,
-      );
+    async listMessages(parameters) {
+      const clientParams = {
+        apiKey: parameters.apiKey,
+        baseURL: parameters.apiBase,
+        organization: parameters.organization,
+      }
+      const openai = new OpenAI(clientParams);
+
+      const id = parameters.payload.thread_id;
+      const response = await openai.beta.threads.messages.list(id);
+
+      return response.body;
     }
-    createMessage(parameters) {
-      const threadId = parameters.body.thread_id;
-      const customHeaders = { "OpenAI-Beta": "assistants=v1" };
-      delete parameters.body.thread_id;
-      return this.postToEndpoint(
-        `/threads/${threadId}/messages`,
-        parameters,
-        null,
-        null,
-        null,
-        customHeaders,
-      );
+    async createMessage(parameters) {
+      const clientParams = {
+        apiKey: parameters.apiKey,
+        baseURL: parameters.apiBase,
+        organization: parameters.organization,
+      }
+      const openai = new OpenAI(clientParams);
+
+      const thread_id = parameters.payload.thread_id;
+      delete parameters.payload.thread_id;
+
+      const response = await openai.beta.threads.messages.create(thread_id, {
+        ...parameters.payload,
+      });
+
+      return response;
     }
-    getMessage(parameters) {
-      const threadId = parameters.body.thread_id;
-      const messageId = parameters.body.message_id;
-      const customHeaders = { "OpenAI-Beta": "assistants=v1" };
-      delete parameters.body.thread_id;
-      delete parameters.body.message_id;
-      return this.getFromEndpoint(
-        `/threads/${threadId}/messages/${messageId}`,
-        parameters,
-        null,
-        customHeaders,
+    async getMessage(parameters) {
+      const clientParams = {
+        apiKey: parameters.apiKey,
+        baseURL: parameters.apiBase,
+        organization: parameters.organization,
+      }
+      const openai = new OpenAI(clientParams);
+
+      const thread_id = parameters.payload.thread_id;
+      const message_id = parameters.payload.message_id;
+
+      const response = await openai.beta.threads.messages.retrieve(
+        thread_id,
+        message_id,
       );
+
+      return response;
     }
-    modifyMessage(parameters) {
-      const threadId = parameters.body.thread_id;
-      const messageId = parameters.body.message_id;
-      const customHeaders = { "OpenAI-Beta": "assistants=v1" };
-      delete parameters.body.thread_id;
-      delete parameters.body.message_id;
-      return this.postToEndpoint(
-        `/threads/${threadId}/messages/${messageId}`,
-        parameters,
-        null,
-        null,
-        null,
-        customHeaders,
+    async modifyMessage(parameters) {
+      const clientParams = {
+        apiKey: parameters.apiKey,
+        baseURL: parameters.apiBase,
+        organization: parameters.organization,
+      }
+      const openai = new OpenAI(clientParams);
+
+      const thread_id = parameters.payload.thread_id;
+      const message_id = parameters.payload.message_id;
+      delete parameters.payload.thread_id;
+      delete parameters.payload.message_id;
+
+      const response = await openai.beta.threads.messages.update(
+        thread_id,
+        message_id,
+        {
+          ...parameters.payload,
+        },
       );
-    }
-    createThreadAndRun(parameters) {
-      const customHeaders = { "OpenAI-Beta": "assistants=v1" };
 
-      return this.postToEndpoint(
-        "/threads/runs",
-        parameters,
-        null,
-        null,
-        null,
-        customHeaders,
-      );
+      return response;
     }
-    listRuns(parameters) {
-      const customHeaders = { "OpenAI-Beta": "assistants=v1" };
-      const expectedQueryParameters = ["limit", "order", "after", "before"];
-      const threadId = parameters.body.thread_id;
-      delete parameters.body.thread_id;
-      return this.getFromEndpoint(
-        `/threads/${threadId}/runs`,
-        parameters,
-        expectedQueryParameters,
-        customHeaders,
-      );
+    async createThreadAndRun(parameters) {
+      const clientParams = {
+        apiKey: parameters.apiKey,
+        baseURL: parameters.apiBase,
+        organization: parameters.organization,
+      }
+      const openai = new OpenAI(clientParams);
+
+      const response = await openai.beta.threads.createAndRun({
+        ...parameters.payload,
+      });
+
+      return response;
     }
-    createRun(parameters) {
-      const customHeaders = { "OpenAI-Beta": "assistants=v1" };
-      const threadId = parameters.body.thread_id;
-      delete parameters.body.thread_id;
-      return this.postToEndpoint(
-        `/threads/${threadId}/runs`,
-        parameters,
-        null,
-        null,
-        null,
-        customHeaders,
-      );
+    async listRuns(parameters) {
+      const clientParams = {
+        apiKey: parameters.apiKey,
+        baseURL: parameters.apiBase,
+        organization: parameters.organization,
+      }
+      const openai = new OpenAI(clientParams);
+
+      const thred_id = parameters.payload.thread_id;
+      delete parameters.payload.thread_id;
+
+      const response = await openai.beta.threads.runs.list(thred_id, {
+        ...parameters.payload,
+      });
+
+      return response.body;
     }
-    getRun(parameters) {
-      const customHeaders = { "OpenAI-Beta": "assistants=v1" };
-      const threadId = parameters.body.thread_id;
-      const runId = parameters.body.run_id;
-      delete parameters.body.thread_id;
-      delete parameters.body.run_id;
-      return this.getFromEndpoint(
-        `/threads/${threadId}/runs/${runId}`,
-        parameters,
-        null,
-        customHeaders,
-      );
+    async createRun(parameters) {
+      const clientParams = {
+        apiKey: parameters.apiKey,
+        baseURL: parameters.apiBase,
+        organization: parameters.organization,
+      }
+      const openai = new OpenAI(clientParams);
+
+      const thread_id = parameters.payload.thread_id;
+      delete parameters.payload.thread_id;
+
+      const response = await openai.beta.threads.runs.create(thread_id, {
+        ...parameters.payload,
+      });
+
+      return response;
     }
-    modifyRun(parameters) {
-      const customHeaders = { "OpenAI-Beta": "assistants=v1" };
-      const threadId = parameters.body.thread_id;
-      const runId = parameters.body.run_id;
-      delete parameters.body.thread_id;
-      delete parameters.body.run_id;
-      return this.postToEndpoint(
-        `/threads/${threadId}/runs/${runId}`,
-        parameters,
-        null,
-        null,
-        null,
-        customHeaders,
+    async getRun(parameters) {
+      const clientParams = {
+        apiKey: parameters.apiKey,
+        baseURL: parameters.apiBase,
+        organization: parameters.organization,
+      }
+      const openai = new OpenAI(clientParams);
+
+      const thread_id = parameters.payload.thread_id;
+      const run_id = parameters.payload.run_id;
+      delete parameters.payload.thread_id;
+      delete parameters.payload.run_id;
+
+      const response = await openai.beta.threads.runs.retrieve(
+        thread_id,
+        run_id,
       );
+
+      return response;
     }
-    submitToolOuputsToRun(parameters) {
-      const customHeaders = { "OpenAI-Beta": "assistants=v1" };
-      const threadId = parameters.body.thread_id;
-      const runId = parameters.body.run_id;
-      delete parameters.body.thread_id;
-      delete parameters.body.run_id;
-      return this.postToEndpoint(
-        `/threads/${threadId}/runs/${runId}/submit_tool_outputs`,
-        parameters,
-        null,
-        null,
-        null,
-        customHeaders,
+    async modifyRun(parameters) {
+      const clientParams = {
+        apiKey: parameters.apiKey,
+        baseURL: parameters.apiBase,
+        organization: parameters.organization,
+      }
+      const openai = new OpenAI(clientParams);
+
+      const thread_id = parameters.payload.thread_id;
+      const run_id = parameters.payload.run_id;
+      delete parameters.payload.thread_id;
+      delete parameters.payload.run_id;
+
+      const response = await openai.beta.threads.runs.update(
+        thread_id,
+        run_id,
+        {
+          ...parameters.payload,
+        },
       );
+
+      return response;
     }
-    cancelRun(parameters) {
-      const customHeaders = { "OpenAI-Beta": "assistants=v1" };
-      const threadId = parameters.body.thread_id;
-      const runId = parameters.body.run_id;
-      delete parameters.body.thread_id;
-      delete parameters.body.run_id;
-      return this.postToEndpoint(
-        `/threads/${threadId}/runs/${runId}/cancel`,
-        parameters,
-        null,
-        null,
-        null,
-        customHeaders,
+    async submitToolOuputsToRun(parameters) {
+      const clientParams = {
+        apiKey: parameters.apiKey,
+        baseURL: parameters.apiBase,
+        organization: parameters.organization,
+      }
+      const openai = new OpenAI(clientParams);
+
+      const thread_id = parameters.payload.thread_id;
+      const run_id = parameters.payload.run_id;
+      delete parameters.payload.thread_id;
+      delete parameters.payload.run_id;
+
+      const response = await openai.beta.threads.runs.submitToolOutputs(
+        thread_id,
+        run_id,
+        {
+          ...parameters.payload,
+        },
       );
+
+      return response;
     }
-    listRunSteps(parameters) {
-      const customHeaders = { "OpenAI-Beta": "assistants=v1" };
-      const threadId = parameters.body.thread_id;
-      const runId = parameters.body.run_id;
-      const expectedQueryParameters = ["limit", "order", "after", "before"];
-      delete parameters.body.thread_id;
-      delete parameters.body.run_id;
-      return this.getFromEndpoint(
-        `/threads/${threadId}/runs/${runId}/steps`,
-        parameters,
-        expectedQueryParameters,
-        customHeaders,
+    async cancelRun(parameters) {
+      const clientParams = {
+        apiKey: parameters.apiKey,
+        baseURL: parameters.apiBase,
+        organization: parameters.organization,
+      }
+      const openai = new OpenAI(clientParams);
+
+      const thread_id = parameters.payload.thread_id;
+      const run_id = parameters.payload.run_id;
+      delete parameters.payload.thread_id;
+      delete parameters.payload.run_id;
+
+      const response = await openai.beta.threads.runs.cancel(
+        thread_id,
+        run_id,
+        {
+          ...parameters.payload,
+        },
       );
+
+      return response;
     }
-    getRunStep(parameters) {
-      const customHeaders = { "OpenAI-Beta": "assistants=v1" };
-      const threadId = parameters.body.thread_id;
-      const runId = parameters.body.run_id;
-      const stepId = parameters.body.step_id;
-      delete parameters.body.thread_id;
-      delete parameters.body.step_id;
-      return this.getFromEndpoint(
-        `/threads/${threadId}/runs/${runId}/steps/${stepId}`,
-        parameters,
-        null,
-        customHeaders,
+    async listRunSteps(parameters) {
+      const clientParams = {
+        apiKey: parameters.apiKey,
+        baseURL: parameters.apiBase,
+        organization: parameters.organization,
+      }
+      const openai = new OpenAI(clientParams);
+
+      const thread_id = parameters.payload.thread_id;
+      const run_id = parameters.payload.run_id;
+      delete parameters.payload.thread_id;
+      delete parameters.payload.run_id;
+
+      const response = await openai.beta.threads.runs.steps.list(
+        thread_id,
+        run_id,
+        {
+          ...parameters.payload,
+        },
       );
+
+      return response.body;
     }
-    listAssistantFiles(parameters) {
-      const customHeaders = { "OpenAI-Beta": "assistants=v1" };
-      const assistantId = parameters.body.assistant_id;
-      const expectedQueryParameters = ["limit", "order", "after", "before"];
-      delete parameters.body.assistant_id;
-      return this.getFromEndpoint(
-        `/assistants/${assistantId}/files`,
-        parameters,
-        expectedQueryParameters,
-        customHeaders,
+    async getRunStep(parameters) {
+      const clientParams = {
+        apiKey: parameters.apiKey,
+        baseURL: parameters.apiBase,
+        organization: parameters.organization,
+      }
+      const openai = new OpenAI(clientParams);
+
+      const thread_id = parameters.payload.thread_id;
+      const run_id = parameters.payload.run_id;
+      const step_id = parameters.payload.step_id;
+
+      const response = await openai.beta.threads.runs.steps.retrieve(
+        thread_id,
+        run_id,
+        step_id,
       );
+
+      return response;
     }
-    createAssistantFile(parameters) {
-      const customHeaders = { "OpenAI-Beta": "assistants=v1" };
-      const assistantId = parameters.body.assistant_id;
-      delete parameters.body.assistant_id;
-      return this.postToEndpoint(
-        `/assistants/${assistantId}/files`,
-        parameters,
-        null,
-        null,
-        null,
-        customHeaders,
-      );
+    async listAssistantFiles(parameters) {
+      const clientParams = {
+        apiKey: parameters.apiKey,
+        baseURL: parameters.apiBase,
+        organization: parameters.organization,
+      }
+      const openai = new OpenAI(clientParams);
+
+      const assistant_id = parameters.payload.assistant_id;
+      delete parameters.payload.assistant_id;
+
+      const response = await openai.beta.assistants.files.list(assistant_id, {
+        ...parameters.payload,
+      });
+
+      return response.body;
     }
-    getAssistantFile(parameters) {
-      const customHeaders = { "OpenAI-Beta": "assistants=v1" };
-      const assistantId = parameters.body.assistant_id;
-      const fileId = parameters.body.file_id;
-      delete parameters.body.assistant_id;
-      delete parameters.body.file_id;
-      return this.getFromEndpoint(
-        `/assistants/${assistantId}/files/${fileId}`,
-        parameters,
-        null,
-        customHeaders,
-      );
+    async createAssistantFile(parameters) {
+      const clientParams = {
+        apiKey: parameters.apiKey,
+        baseURL: parameters.apiBase,
+        organization: parameters.organization,
+      }
+      const openai = new OpenAI(clientParams);
+
+      const assistant_id = parameters.payload.assistant_id;
+      delete parameters.payload.assistant_id;
+
+      const response = await openai.beta.assistants.files.create(assistant_id, {
+        ...parameters.payload,
+      });
+
+      return response;
     }
-    deleteAssistantFile(parameters) {
-      const customHeaders = { "OpenAI-Beta": "assistants=v1" };
-      const assistantId = parameters.body.assistant_id;
-      const fileId = parameters.body.file_id;
-      delete parameters.body.assistant_id;
-      delete parameters.body.file_id;
-      return this.deleteFromEndpoint(
-        `/assistants/${assistantId}/files/${fileId}`,
-        parameters,
-        null,
-        customHeaders,
+    async getAssistantFile(parameters) {
+      const clientParams = {
+        apiKey: parameters.apiKey,
+        baseURL: parameters.apiBase,
+        organization: parameters.organization,
+      }
+      const openai = new OpenAI(clientParams);
+
+      const assistant_id = parameters.payload.assistant_id;
+      const file_id = parameters.payload.file_id;
+      delete parameters.payload.assistant_id;
+      delete parameters.payload.file_id;
+
+      const response = await openai.beta.assistants.files.retrieve(
+        assistant_id,
+        file_id,
+        {
+          ...parameters.payload,
+        },
       );
+
+      return response;
     }
-    listMessageFiles(parameters) {
-      const customHeaders = { "OpenAI-Beta": "assistants=v1" };
-      const threadId = parameters.body.thread_id;
-      const messageId = parameters.body.message_id;
-      const expectedQueryParameters = ["limit", "order", "after", "before"];
-      delete parameters.body.thread_id;
-      delete parameters.body.message_id;
-      return this.getFromEndpoint(
-        `/threads/${threadId}/messages/${messageId}/files`,
-        parameters,
-        expectedQueryParameters,
-        customHeaders,
+    async deleteAssistantFile(parameters) {
+      const clientParams = {
+        apiKey: parameters.apiKey,
+        baseURL: parameters.apiBase,
+        organization: parameters.organization,
+      }
+      const openai = new OpenAI(clientParams);
+
+      const assistant_id = parameters.payload.assistant_id;
+      const file_id = parameters.payload.file_id;
+      delete parameters.payload.assistant_id;
+      delete parameters.payload.file_id;
+
+      const response = await openai.beta.assistants.files.del(
+        assistant_id,
+        file_id,
+        {
+          ...parameters.payload,
+        },
       );
+
+      return response;
     }
-    getMessageFile(parameters) {
-      const customHeaders = { "OpenAI-Beta": "assistants=v1" };
-      const threadId = parameters.body.thread_id;
-      const messageId = parameters.body.message_id;
-      const fileId = parameters.body.file_id;
-      delete parameters.body.thread_id;
-      delete parameters.body.message_id;
-      delete parameters.body.file_id;
-      return this.getFromEndpoint(
-        `/threads/${threadId}/messages/${messageId}/files/${fileId}`,
-        parameters,
-        null,
-        customHeaders,
+    async listMessageFiles(parameters) {
+      const clientParams = {
+        apiKey: parameters.apiKey,
+        baseURL: parameters.apiBase,
+        organization: parameters.organization,
+      }
+      const openai = new OpenAI(clientParams);
+
+      const thread_id = parameters.payload.thread_id;
+      const message_id = parameters.payload.message_id;
+      delete parameters.payload.thread_id;
+      delete parameters.payload.message_id;
+
+      const response = await openai.beta.threads.messages.files.list(
+        thread_id,
+        message_id,
+        {
+          ...parameters.payload,
+        },
       );
-    }
-  }
 
-  function mergeQueryParams(parameters, queryParameters) {
-    if (parameters.$queryParameters) {
-      Object.keys(parameters.$queryParameters).forEach(
-        function (parameterName) {
-          var parameter = parameters.$queryParameters[parameterName];
-          queryParameters[parameterName] = parameter;
+      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.payload.thread_id;
+      const message_id = parameters.payload.message_id;
+      const file_id = parameters.payload.file_id;
+
+      delete parameters.payload.thread_id;
+      delete parameters.payload.message_id;
+      delete parameters.payload.file_id;
+
+      const response = await openai.beta.threads.messages.files.retrieve(
+        thread_id,
+        message_id,
+        file_id,
+        {
+          ...parameters.payload,
         },
       );
+
+      return response;
     }
-    return queryParameters;
   }
 
   return OpenaiApi;