@pipedream/openai 0.0.1 → 0.1.0

package/actions/create-embeddings/create-embeddings.mjs

@@ -0,0 +1,51 @@
+import openai from "../../app/openai.app.mjs";
+import common from "../common/common.mjs";
+import { ConfigurationError } from "@pipedream/platform";
+
+export default {
+  name: "Create Embeddings",
+  version: "0.0.1",
+  key: "openai-create-embeddings",
+  description: "Get a vector representation of a given input that can be easily consumed by machine learning models and algorithms. [See the docs here](https://platform.openai.com/docs/api-reference/embeddings)",
+  type: "action",
+  props: {
+    openai,
+    modelId: {
+      propDefinition: [
+        openai,
+        "embeddingsModelId",
+      ],
+    },
+    input: {
+      label: "Input",
+      description: "Input text to get embeddings for, encoded as a string or array of tokens. To get embeddings for multiple inputs in a single request, pass an array of strings or array of token arrays. Each input must not exceed 8192 tokens in length.",
+      type: "string[]",
+    },
+    user: common.props.user,
+  },
+  async run({ $ }) {
+    // Confirm no element is more than 8192 tokens in length
+    for (const [
+      i,
+      element,
+    ] of this.input.entries()) {
+      if (element.length > 8192) {
+        throw new ConfigurationError(`Element #${i} is more than 8192 tokens in length. Each input must not exceed 8192 tokens in length.`);
+      }
+    }
+
+    const response = await this.openai.createEmbeddings({
+      $,
+      args: {
+        model: this.modelId,
+        input: this.input,
+      },
+    });
+
+    if (response) {
+      $.export("$summary", "Successfully created embeddings");
+    }
+
+    return response;
+  },
+};

package/actions/create-image/create-image.mjs

@@ -1,11 +1,11 @@
-import openai from "../../openai.app.mjs";
+import openai from "../../app/openai.app.mjs";
 import constants from "../common/constants.mjs";
 
 export default {
   name: "Create Image",
-  version: "0.0.1",
+  version: "0.1.0",
   key: "openai-create-image",
-  description: "Creates an image given a prompt. [See docs here](https://beta.openai.com/docs/api-reference/images/create)",
+  description: "Creates an image given a prompt. returns a URL to the image. [See docs here](https://platform.openai.com/docs/api-reference/images)",
   type: "action",
   props: {
     openai,
@@ -27,18 +27,11 @@ export default {
       optional: true,
       options: constants.IMAGE_SIZES,
     },
-    responseFormat: {
-      label: "Response Format",
-      description: "The format in which the generated images are returned.",
-      type: "string",
-      optional: true,
-      options: constants.RESPONSE_FORMATS,
-    },
   },
   async run({ $ }) {
     const response = await this.openai.createImage({
       $,
-      data: {
+      args: {
         prompt: this.prompt,
         n: this.n,
         size: this.size,
@@ -46,8 +39,8 @@ export default {
       },
     });
 
-    if (response) {
-      $.export("$summary", `Successfully created image with id ${response.id}`);
+    if (response.data.length) {
+      $.export("$summary", `Successfully created ${response.data.length} images`);
     }
 
     return response;

package/actions/create-transcription/create-transcription.mjs

@@ -0,0 +1,133 @@
+import fs from "fs";
+import got from "got";
+import { extname } from "path";
+import FormData from "form-data";
+import { ConfigurationError } from "@pipedream/platform";
+import common from "../common/common.mjs";
+import constants from "../common/constants.mjs";
+import lang from "../common/lang.mjs";
+import openai from "../../app/openai.app.mjs";
+
+const COMMON_AUDIO_FORMATS_TEXT = "Your audio file must be in one of these formats: mp3, mp4, mpeg, mpga, m4a, wav, or webm.";
+
+export default {
+  name: "Create Transcription",
+  version: "0.0.1",
+  key: "openai-create-transcription",
+  description: "Transcribes audio into the input language. [See docs here](https://platform.openai.com/docs/api-reference/audio/create).",
+  type: "action",
+  props: {
+    openai,
+    uploadType: {
+      label: "Audio Upload Type",
+      description: "Are you uploading an audio file from [your workflow's `/tmp` directory](https://pipedream.com/docs/code/nodejs/working-with-files/#the-tmp-directory), or providing a URL to the file?",
+      type: "string",
+      options: [
+        "File",
+        "URL",
+      ],
+      reloadProps: true,
+    },
+    language: {
+      label: "Language",
+      description: "**Optional**. The language of the input audio. Supplying the input language will improve accuracy and latency.",
+      type: "string",
+      optional: true,
+      default: "en",
+      options: lang.LANGUAGES.map((l) => ({
+        label: l.label,
+        value: l.value,
+      })),
+    },
+  },
+  async additionalProps() {
+    const props = {};
+    switch (this.uploadType) {
+    case "File":
+      props.path = {
+        type: "string",
+        label: "File Path",
+        description: `A path to your audio file to transcribe, e.g. \`/tmp/audio.mp3\`. ${COMMON_AUDIO_FORMATS_TEXT} Add the appropriate extension (mp3, mp4, etc.) on your filename — OpenAI uses the extension to determine the file type. [See the Pipedream docs on saving files to \`/tmp\`](https://pipedream.com/docs/code/nodejs/working-with-files/#writing-a-file-to-tmp)`,
+      };
+      break;
+    case "URL":
+      props.url = {
+        type: "string",
+        label: "URL",
+        description: `A public URL to the audio file to transcribe. This URL must point directly to the audio file, not a webpage that links to the audio file. ${COMMON_AUDIO_FORMATS_TEXT}`,
+      };
+      break;
+    default:
+      throw new ConfigurationError("Invalid upload type specified. Please provide 'File' or 'URL'.");
+    }
+    // Because we need to display the file or URL above, and not below, these optional props
+    // TODO: Will be fixed when we render optional props correctly when used with additionalProps
+    props.prompt = {
+      label: "Prompt",
+      description: "**Optional** text to guide the model's style or continue a previous audio segment. The [prompt](https://platform.openai.com/docs/guides/speech-to-text/prompting) should match the audio language.",
+      type: "string",
+      optional: true,
+    };
+    props.responseFormat = {
+      label: "Response Format",
+      description: "**Optional**. The format of the response. The default is `json`.",
+      type: "string",
+      default: "json",
+      optional: true,
+      options: constants.TRANSCRIPTION_FORMATS,
+    };
+    props.temperature = common.props.temperature;
+
+    return props;
+  },
+  async run({ $ }) {
+    const {
+      url,
+      path,
+    } = this;
+
+    if (!url && !path) {
+      throw new Error("Must specify either File URL or File Path");
+    }
+
+    const form = new FormData();
+    form.append("model", "whisper-1");
+    if (this.prompt) form.append("prompt", this.prompt);
+    if (this.temperature) form.append("temperature", this.temperature);
+    if (this.language) form.append("language", this.language);
+    if (this.responseFormat) form.append("response_format", this.responseFormat);
+
+    if (path) {
+      if (!fs.existsSync(path)) {
+        throw new Error(`${path} does not exist`);
+      }
+      const readStream = fs.createReadStream(path);
+      form.append("file", readStream);
+    } else if (url) {
+      const ext = extname(url);
+      // OpenAI only supports a few audio formats and uses the extension to determine the format
+      const tempFilePath = `/tmp/audioFile${ext}`;
+
+      const writeStream = fs.createWriteStream(tempFilePath);
+      const responseStream = got.stream(url);
+      responseStream.pipe(writeStream);
+      await new Promise((resolve, reject) => {
+        writeStream.on("finish", resolve);
+        writeStream.on("error", reject);
+        responseStream.on("error", reject);
+      });
+      const readStream = fs.createReadStream(tempFilePath);
+      form.append("file", readStream);
+    }
+    const response = await this.openai.createTranscription({
+      $,
+      form,
+    });
+
+    if (response) {
+      $.export("$summary", "Successfully created transcription");
+    }
+
+    return response;
+  },
+};

package/actions/send-prompt/send-prompt.mjs

@@ -1,105 +1,44 @@
-import openai from "../../openai.app.mjs";
+import openai from "../../app/openai.app.mjs";
+import common from "../common/common.mjs";
 
 export default {
-  name: "Send Prompt",
-  version: "0.0.1",
+  ...common,
+  name: "Create Completion (Send Prompt)",
+  version: "0.1.0",
   key: "openai-send-prompt",
-  description: "Creates a completion for the provided prompt and parameters. [See docs here](https://beta.openai.com/docs/api-reference/completions/create)",
+  description: "OpenAI recommends using the **Chat** action for the latest `gpt-3.5-turbo` API, since it's faster and 10x cheaper. This action creates a completion for the provided prompt and parameters using the older `/completions` API. [See docs here](https://beta.openai.com/docs/api-reference/completions/create)",
   type: "action",
   props: {
     openai,
     modelId: {
       propDefinition: [
         openai,
-        "modelId",
+        "completionModelId",
       ],
     },
     prompt: {
       label: "Prompt",
-      description: "The prompt(s) to generate completions for, encoded as a string, array of strings, array of tokens, or array of token arrays. Note that <|endoftext|> is the document separator that the model sees during training, so if a prompt is not specified the model will generate as if from the beginning of a new document.",
-      type: "string[]",
-      optional: true,
+      description: "The prompt to generate completions for",
+      type: "string",
     },
     suffix: {
       label: "Suffix",
-      description: "The suffix that comes after a completion of inserted text.",
-      type: "string",
-      optional: true,
-    },
-    maxTokens: {
-      label: "Max Tokens",
-      description: "The maximum number of [tokens](https://beta.openai.com/tokenizer) to generate in the completion.",
-      type: "integer",
-      optional: true,
-    },
-    temperature: {
-      label: "Temperature",
-      description: "What [sampling temperature](https://towardsdatascience.com/how-to-sample-from-language-models-682bceb97277) to use. Higher values means the model will take more risks. Try 0.9 for more creative applications, and 0 (argmax sampling) for ones with a well-defined answer.",
-      type: "string",
-      optional: true,
-    },
-    topP: {
-      label: "Top P",
-      description: "An alternative to sampling with temperature, called nucleus sampling, where the model considers the results of the tokens with top_p probability mass. So 0.1 means only the tokens comprising the top 10% probability mass are considered. We generally recommend altering this or `temperature` but not both.",
-      type: "string",
-      optional: true,
-    },
-    n: {
-      label: "N",
-      description: "How many completions to generate for each prompt.",
-      type: "string",
-      optional: true,
-    },
-    stop: {
-      label: "Stop",
-      description: "Up to 4 sequences where the API will stop generating further tokens. The returned text will not contain the stop sequence.",
-      type: "string[]",
-      optional: true,
-    },
-    presencePenalty: {
-      label: "Presence Penalty",
-      description: "Number between -2.0 and 2.0. Positive values penalize new tokens based on whether they appear in the text so far, increasing the model's likelihood to talk about new topics.",
-      type: "string",
-      optional: true,
-    },
-    frequencyPenalty: {
-      label: "Frequency Penalty",
-      description: "Number between -2.0 and 2.0. Positive values penalize new tokens based on their existing frequency in the text so far, decreasing the model's likelihood to repeat the same line verbatim.",
+      description: "The suffix that comes after a completion of inserted text",
       type: "string",
       optional: true,
     },
+    ...common.props,
     bestOf: {
       label: "Best Of",
-      description: "Generates best_of completions server-side and returns the \"best\" (the one with the highest log probability per token). Results cannot be streamed.",
+      description: "Generates best_of completions server-side and returns the \"best\" (the one with the highest log probability per token). If set, results cannot be streamed.",
       type: "integer",
       optional: true,
     },
   },
   async run({ $ }) {
-    const response = await this.openai.sendPrompt({
+    const response = await this.openai.createCompletion({
       $,
-      data: {
-        model: this.modelId,
-        prompt: this.prompt,
-        max_tokens: this.maxTokens,
-        temperature: this.temperature
-          ? +this.temperature
-          : this.temperature,
-        top_p: this.topP
-          ? +this.topP
-          : this.topP,
-        n: this.n
-          ? +this.n
-          : this.n,
-        stop: this.stop,
-        presence_penalty: this.presencePenalty
-          ? +this.presencePenalty
-          : this.presencePenalty,
-        frequency_penalty: this.frequencyPenalty
-          ? +this.frequencyPenalty
-          : this.frequencyPenalty,
-        best_of: this.bestOf,
-      },
+      args: this._getCommonArgs(),
     });
 
     if (response) {

package/actions/summarize/summarize.mjs

@@ -0,0 +1,55 @@
+import common from "../common/common-helper.mjs";
+
+export default {
+  ...common,
+  name: "Summarize Text",
+  version: "0.0.1",
+  key: "openai-summarize",
+  description: "Summarizes text using the Chat API",
+  type: "action",
+  props: {
+    text: {
+      label: "Text",
+      description: "The text to summarize",
+      type: "string",
+    },
+    length: {
+      label: "Summary Length",
+      description: "The length of the summary",
+      type: "string",
+      optional: true,
+      options: [
+        "word",
+        "sentence",
+        "paragraph",
+        "page",
+      ],
+    },
+    ...common.props,
+  },
+  methods: {
+    ...common.methods,
+    systemInstructions() {
+      return "Your goal is to summarize the text the user provides. Please follow the length guidelines presented in the prompt.";
+    },
+    maxLength() {
+      return this.length
+        ? ` in one ${this.length}`
+        : "";
+    },
+    userMessage() {
+      return `Summarize the following text${this.maxLength()}: ${this.text}`;
+    },
+    formatOutput({
+      messages, response,
+    }) {
+      if (!messages || !response) {
+        throw new Error("Invalid API output, please reach out to https://pipedream.com/support");
+      }
+      return {
+        summary: response.choices?.[0]?.message?.content,
+        messages,
+      };
+    },
+  },
+};

package/actions/translate-text/translate-text.mjs

@@ -0,0 +1,62 @@
+import common from "../common/common-helper.mjs";
+import lang from "../common/lang.mjs";
+
+const langOptions = lang.LANGUAGES.map((l) => ({
+  label: l.label,
+  value: l.value,
+}));
+
+export default {
+  ...common,
+  name: "Translate Text",
+  version: "0.0.1",
+  key: "openai-translate-text",
+  description: "Translate text from one language to another using the Chat API",
+  type: "action",
+  props: {
+    ...common.props,
+    text: {
+      label: "Text",
+      description: "Text to translate",
+      type: "string",
+    },
+    sourceLang: {
+      label: "Source language",
+      description: "The language of your provided text",
+      type: "string",
+      options: langOptions,
+    },
+    targetLang: {
+      label: "Target language",
+      description: "The language you want to translate your text to",
+      type: "string",
+      options: langOptions,
+    },
+  },
+  methods: {
+    ...common.methods,
+    systemInstructions() {
+      return "Your goal is to translate the text the user provides. Please follow the language guidelines presented in the prompt.";
+    },
+    userMessage() {
+      return `Translate the following text from ISO 639-1 ${this.sourceLang} to ISO 639-1 ${this.targetLang}:\n\n${this.text}`;
+    },
+    summarize() {
+      return `Translated text from ${this.sourceLang} to ${this.targetLang}`;
+    },
+    formatOutput({
+      messages, response,
+    }) {
+      if (!messages || !response) {
+        throw new Error("Invalid API output, please reach out to https://pipedream.com/support");
+      }
+
+      return {
+        translation: response.choices?.[0]?.message?.content,
+        source_lang: this.sourceLang,
+        target_lang: this.targetLang,
+        messages,
+      };
+    },
+  },
+};

package/app/openai.app.mjs

@@ -0,0 +1,179 @@
+import { axios } from "@pipedream/platform";
+
+export default {
+  type: "app",
+  app: "openai",
+  propDefinitions: {
+    completionModelId: {
+      label: "Model",
+      description: "The ID of the model to use for completions. **This action doesn't support the ChatGPT `turbo` models**. Use the **Chat** action for those, instead.",
+      type: "string",
+      async options() {
+        return (await this.getCompletionModels({})).map((model) => model.id);
+      },
+      default: "text-davinci-003",
+    },
+    chatCompletionModelId: {
+      label: "Model",
+      description: "The ID of the model to use for chat completions",
+      type: "string",
+      async options() {
+        return (await this.getChatCompletionModels({})).map((model) => model.id);
+      },
+      default: "gpt-3.5-turbo",
+    },
+    embeddingsModelId: {
+      label: "Model",
+      description: "The ID of the embeddings model to use. OpenAI recommends using `text-embedding-ada-002` for nearly all use cases: \"It's better, cheaper, and simpler to use. [Read the blog post announcement](https://openai.com/blog/new-and-improved-embedding-model)\".",
+      type: "string",
+      async options() {
+        return (await this.getEmbeddingsModels({})).map((model) => model.id);
+      },
+      default: "text-embedding-ada-002",
+    },
+  },
+  methods: {
+    _apiKey() {
+      return this.$auth.api_key;
+    },
+    _baseApiUrl() {
+      return "https://api.openai.com/v1";
+    },
+    _commonHeaders() {
+      return {
+        "Authorization": `Bearer ${this._apiKey()}`,
+        "Accept": "application/json",
+        "User-Agent": "@PipedreamHQ/pipedream v1.0",
+      };
+    },
+    async _makeRequest({
+      $ = this,
+      path,
+      ...args
+    } = {}) {
+      return axios($, {
+        url: `${this._baseApiUrl()}${path}`,
+        headers: {
+          ...this._commonHeaders(),
+        },
+        ...args,
+      });
+    },
+    async models({ $ }) {
+      const { data: models } = await this._makeRequest({
+        $,
+        path: "/models",
+      });
+      return models.sort((a, b) => a?.id.localeCompare(b?.id));
+    },
+    async getChatCompletionModels({ $ }) {
+      const models = await this.models({
+        $,
+      });
+      return models.filter((model) => model.id.match(/turbo/gi));
+    },
+    async getCompletionModels({ $ }) {
+      const models = await this.models({
+        $,
+      });
+      return models.filter((model) => {
+        const { id } = model;
+        return (
+          id.match(/^(?=.*\b(babbage|davinci|ada|curie)\b)(?!.*\b(whisper|turbo|edit|insert|search|embedding|similarity|001)\b).*$/gm)
+        );
+      });
+    },
+    async getEmbeddingsModels({ $ }) {
+      const models = await this.models({
+        $,
+      });
+      return models.filter((model) => {
+        const { id } = model;
+        return (
+          id.match(/^(text-embedding-ada-002|.*-(davinci|curie|babbage|ada)-.*-001)$/gm)
+        );
+      });
+    },
+    async _makeCompletion({
+      $, path, args,
+    }) {
+      const data = await this._makeRequest({
+        $,
+        path,
+        method: "POST",
+        data: args,
+      });
+
+      // For completions, return the text of the first choice at the top-level
+      let generated_text;
+      if (path === "/completions") {
+        const { choices } = data;
+        generated_text = choices?.[0]?.text;
+      }
+      // For chat completions, return the assistant message at the top-level
+      let generated_message;
+      if (path === "/chat/completions") {
+        const { choices } = data;
+        generated_message = choices?.[0]?.message;
+      }
+
+      return {
+        generated_text,
+        generated_message,
+        ...data,
+      };
+    },
+    async createCompletion({
+      $, args,
+    }) {
+      return this._makeCompletion({
+        $,
+        path: "/completions",
+        args,
+      });
+    },
+    async createChatCompletion({
+      $, args,
+    }) {
+      return this._makeCompletion({
+        $,
+        path: "/chat/completions",
+        args,
+      });
+    },
+    async createImage({
+      $, args,
+    }) {
+      return this._makeRequest({
+        $,
+        path: "/images/generations",
+        data: args,
+        method: "POST",
+      });
+    },
+    async createEmbeddings({
+      $, args,
+    }) {
+      return this._makeRequest({
+        $,
+        path: "/embeddings",
+        data: args,
+        method: "POST",
+      });
+    },
+    async createTranscription({
+      $, form,
+    }) {
+      return this._makeRequest({
+        $,
+        path: "/audio/transcriptions",
+        method: "POST",
+        headers: {
+          ...this._commonHeaders(),
+          "Content-Type": `multipart/form-data; boundary=${form._boundary}`,
+        },
+        data: form,
+      });
+    },
+  },
+};

package/package.json

@@ -1,20 +1,24 @@
 {
   "name": "@pipedream/openai",
-  "version": "0.0.1",
+  "version": "0.1.0",
   "description": "Pipedream OpenAI Components",
-  "main": "openai.app.mjs",
+  "main": "app/openai.app.mjs",
   "keywords": [
     "pipedream",
     "openai"
   ],
   "homepage": "https://pipedream.com/apps/openai",
   "author": "Pipedream <support@pipedream.com> (https://pipedream.com/)",
-  "license": "MIT",
   "gitHead": "e12480b94cc03bed4808ebc6b13e7fdb3a1ba535",
   "publishConfig": {
     "access": "public"
   },
   "dependencies": {
-    "@pipedream/platform": "^1.2.1"
+    "@pipedream/platform": "^1.2.1",
+    "@pipedream/types": "^0.1.4",
+    "openai": "^3.2.1"
+  },
+  "devDependencies": {
+    "@types/node": "^17.0.45"
   }
 }