@pipedream/openai 0.5.1 → 0.5.3

package/README.md

@@ -1,22 +1,91 @@
 # Overview
 
-The OpenAI API is a powerful tool that provides access to a range of
-high-powered machine learning models. With the OpenAI API, developers can
-create products, services, and tools that enable humanizing AI experiences, and
-build applications that extend the power of human language.
-
-Using the OpenAI API, developers can create language-driven applications such
-as:
-
-- Natural language understanding and sentiment analysis
-- Text-based search
-- Question answering
-- Dialogue systems and conversation agents
-- Intelligent text completion
-- Text summarization
-- Text classification
-- Machine translation
-- Language generation
-- Multi-factor authentication
-- Anomaly detection
-- Text analysis
+OpenAI provides a suite of powerful AI models through its API, enabling developers to integrate advanced natural language processing and generative capabilities into their applications. Here’s an overview of the services offered by OpenAI's API:
+
+- [Text generation](https://platform.openai.com/docs/guides/text-generation)
+- [Embeddings](https://platform.openai.com/docs/guides/embeddings)
+- [Fine-tuning](https://platform.openai.com/docs/guides/fine-tuning)
+- [Image Generation](https://platform.openai.com/docs/guides/images?context=node)
+- [Vision](https://platform.openai.com/docs/guides/vision)
+- [Text-to-Speech](https://platform.openai.com/docs/guides/text-to-speech)
+- [Speech-to-Text](https://platform.openai.com/docs/guides/speech-to-text)
+
+Use Python or Node.js code to make fully authenticated API requests with your OpenAI account:
+
+# Example Use Cases
+
+The OpenAI API can be leveraged in a wide range of business contexts to drive efficiency, enhance customer experiences, and innovate product offerings. Here are some specific business use cases for utilizing the OpenAI API:
+
+### **Customer Support Automation**
+
+Significantly reduce response times and free up human agents to tackle more complex issues by automating customer support ticket responses.
+
+### **Content Creation and Management**
+
+Utilize AI to generate high-quality content for blogs, articles, product descriptions, and marketing material. 
+
+### **Personalized Marketing and Advertising**
+
+Optimize advertising copy and layouts based on user interaction data with a trained model via the Fine Tuning API.
+
+### **Language Translation and Localization**
+
+Use ChatGPT to translate and localize content across multiple languages, expanding your market reach without the need for extensive translation teams.
+
+# Getting Started
+
+First, sign up for an OpenAI account, then in a new workflow step open the OpenAI app:
+
+![Screenshot highlighting the OpenAI (ChatGPT) app selected in the Pipedream workflow automation interface, with a red arrow pointing to the OpenAI option in the sidebar app list.](https://res.cloudinary.com/pipedreamin/image/upload/v1713464578/marketplace/apps/openai/CleanShot_2024-04-18_at_14.22.30_guc5ri.png)
+
+Then select one of the Pre-built actions, or choose to use Node.js or Python:
+
+![Interface showing a list of OpenAI (ChatGPT) actions available in Pipedream, including options for building API requests, using the API in Node.js and Python, and pre-built actions like Chat, Summarize Text, and Create Image (DALL-E).](https://res.cloudinary.com/pipedreamin/image/upload/v1713464768/marketplace/apps/openai/CleanShot_2024-04-18_at_14.25.46_akse9e.png)
+
+Then connect your OpenAI account to Pipedream. Open the [API keys section](https://platform.openai.com/api-keys) in the OpenAI dashboard.
+
+Then select **Create a new secret key:**
+
+![Screenshot of the OpenAI API keys management page with a red arrow pointing to the 'Create new secret key' button for generating new API keys.](https://res.cloudinary.com/pipedreamin/image/upload/v1713464913/marketplace/apps/openai/CleanShot_2024-04-18_at_14.28.03_lw0pbw.png)
+
+Name the key `Pipedream` and then save the API key within Pipedream. Now you’re all set to use pre-built actions like `Chat` or use your OpenAI API key directly in Node.js or Python code.
+
+# Troubleshooting
+
+## 401 - Invalid Authentication
+
+---
+
+Ensure the correct [API key](https://platform.openai.com/account/api-keys) and requesting organization are being used.
+
+## 401 - Incorrect API key provided
+
+---
+
+Ensure the API key used is correct or [generate a new one](https://platform.openai.com/account/api-keys) and then reconnect it to Pipedream.
+
+## 401 - You must be a member of an organization to use the API
+
+Contact OpenAI to get added to a new organization or ask your organization manager to [invite you to an organization](https://platform.openai.com/account/team).
+
+## 403 - Country, region, or territory not supported
+
+You are accessing the API from an unsupported country, region, or territory.
+
+## 429 - Rate limit reached for requests
+
+---
+
+You are sending requests too quickly. Pace your requests. Read the OpenAI [Rate limit guide](https://platform.openai.com/docs/guides/rate-limits). Use [Pipedream Concurrency and Throttling](https://pipedream.com/docs/workflows/concurrency-and-throttling) settings to control the frequency of API calls to OpenAI.
+
+## 429 - You exceeded your current quota, please check your plan and billing details
+
+You have run out of OpenAI credits or hit your maximum monthly spend. [Buy more OpenAI credits](https://platform.openai.com/account/billing) or learn how to [increase your OpenAI account limits](https://platform.openai.com/account/limits).
+
+## 500 - The server had an error while processing your request
+
+Retry your request after a brief wait and contact us if the issue persists. Check the [OpenAI status page](https://status.openai.com/).
+
+## 503 - The engine is currently overloaded, please try again later
+
+OpenAI’s servers are experiencing high amounts of traffic. Please retry your requests after a brief wait.

package/actions/analyze-image-content/analyze-image-content.mjs

@@ -0,0 +1,131 @@
+import openai from "../../openai.app.mjs";
+import common from "../common/common-assistants.mjs";
+import FormData from "form-data";
+import fs from "fs";
+
+export default {
+  ...common,
+  key: "openai-analyze-image-content",
+  name: "Analyze Image Content",
+  description: "Send a message or question about an image and receive a response. [See the documentation](https://platform.openai.com/docs/api-reference/runs/createThreadAndRun)",
+  version: "0.0.1",
+  type: "action",
+  props: {
+    openai,
+    message: {
+      type: "string",
+      label: "Message",
+      description: "The message or question to send",
+    },
+    imageUrl: {
+      type: "string",
+      label: "Image URL",
+      description: "The URL of the image to analyze. Must be a supported image types: jpeg, jpg, png, gif, webp",
+      optional: true,
+    },
+    imageFileId: {
+      propDefinition: [
+        openai,
+        "fileId",
+        () => ({
+          purpose: "vision",
+        }),
+      ],
+      optional: true,
+    },
+    filePath: {
+      type: "string",
+      label: "File Path",
+      description: "The path to a file in the `/tmp` directory. [See the documentation on working with files](https://pipedream.com/docs/code/nodejs/working-with-files/#writing-a-file-to-tmp)",
+      optional: true,
+    },
+  },
+  async run({ $ }) {
+    const { id: assistantId } = await this.openai.createAssistant({
+      $,
+      data: {
+        model: "gpt-4-vision-preview",
+      },
+    });
+
+    const data = {
+      assistant_id: assistantId,
+      thread: {
+        messages: [
+          {
+            role: "user",
+            content: [
+              {
+                type: "text",
+                text: this.message,
+              },
+            ],
+          },
+        ],
+      },
+      model: this.model,
+    };
+    if (this.imageUrl) {
+      data.thread.messages[0].content.push({
+        type: "image_url",
+        image_url: {
+          url: this.imageUrl,
+        },
+      });
+    }
+    if (this.imageFileId) {
+      data.thread.messages[0].content.push({
+        type: "image_file",
+        image_file: {
+          file_id: this.imageFileId,
+        },
+      });
+    }
+    if (this.filePath) {
+      const fileData = new FormData();
+      const content = fs.createReadStream(this.filePath.includes("tmp/")
+        ? this.filePath
+        : `/tmp/${this.filePath}`);
+      fileData.append("purpose", "vision");
+      fileData.append("file", content);
+
+      const { id } = await this.openai.uploadFile({
+        $,
+        data: fileData,
+        headers: fileData.getHeaders(),
+      });
+
+      data.thread.messages[0].content.push({
+        type: "image_file",
+        image_file: {
+          file_id: id,
+        },
+      });
+    }
+
+    let run;
+    run = await this.openai.createThreadAndRun({
+      $,
+      data,
+    });
+    const runId = run.id;
+    const threadId = run.thread_id;
+
+    run = await this.pollRunUntilCompleted(run, threadId, runId, $);
+
+    // get response;
+    const { data: messages } = await this.openai.listMessages({
+      $,
+      threadId,
+      params: {
+        order: "desc",
+      },
+    });
+    const response = messages[0].content[0].text.value;
+    return {
+      response,
+      messages,
+      run,
+    };
+  },
+};

package/actions/cancel-run/cancel-run.mjs

@@ -4,7 +4,7 @@ export default {
   key: "openai-cancel-run",
   name: "Cancel Run (Assistants)",
   description: "Cancels a run that is in progress. [See the documentation](https://platform.openai.com/docs/api-reference/runs/cancelRun)",
-  version: "0.0.6",
+  version: "0.0.7",
   type: "action",
   props: {
     openai,
@@ -26,6 +26,7 @@ export default {
   },
   async run({ $ }) {
     const response = await this.openai.cancelRun({
+      $,
       threadId: this.threadId,
       runId: this.runId,
     });

package/actions/chat/chat.mjs

@@ -1,12 +1,13 @@
 import openai from "../../openai.app.mjs";
 import common from "../common/common.mjs";
+import constants from "../../common/constants.mjs";
 
 export default {
   ...common,
   name: "Chat",
-  version: "0.1.9",
+  version: "0.1.10",
   key: "openai-chat",
-  description: "The Chat API, using the `gpt-3.5-turbo` or `gpt-4` model. [See docs here](https://platform.openai.com/docs/api-reference/chat)",
+  description: "The Chat API, using the `gpt-3.5-turbo` or `gpt-4` model. [See the documentation](https://platform.openai.com/docs/api-reference/chat)",
   type: "action",
   props: {
     openai,
@@ -43,10 +44,7 @@ export default {
       type: "string",
       label: "Response Format",
       description: "Specify the format that the model must output. [Setting to `json_object` guarantees the message the model generates is valid JSON](https://platform.openai.com/docs/api-reference/chat/create#chat-create-response_format). Defaults to `text`",
-      options: [
-        "text",
-        "json_object",
-      ],
+      options: constants.CHAT_RESPONSE_FORMATS,
       optional: true,
       default: "text",
     },
@@ -57,7 +55,7 @@ export default {
 
     const response = await this.openai.createChatCompletion({
       $,
-      args,
+      data: args,
     });
 
     if (response) {

package/actions/chat-with-assistant/chat-with-assistant.mjs

@@ -0,0 +1,135 @@
+import openai from "../../openai.app.mjs";
+import common from "../common/common-assistants.mjs";
+
+export default {
+  ...common,
+  key: "openai-chat-with-assistant",
+  name: "Chat with Assistant",
+  description: "Sends a message and generates a response, storing the message history for a continuous conversation. [See the documentation](https://platform.openai.com/docs/api-reference/runs/createThreadAndRun)",
+  version: "0.0.2",
+  type: "action",
+  props: {
+    openai,
+    message: {
+      type: "string",
+      label: "Message",
+      description: "The message to send",
+    },
+    assistantId: {
+      propDefinition: [
+        openai,
+        "assistant",
+      ],
+      description: "The assistant to use. Leave blank to create a new assistant",
+      optional: true,
+    },
+    name: {
+      propDefinition: [
+        openai,
+        "name",
+      ],
+    },
+    instructions: {
+      propDefinition: [
+        openai,
+        "instructions",
+      ],
+    },
+    model: {
+      propDefinition: [
+        openai,
+        "assistantModel",
+      ],
+      optional: true,
+      default: "gpt-3.5-turbo",
+    },
+    threadId: {
+      propDefinition: [
+        openai,
+        "threadId",
+      ],
+      description: "The unique identifier for the thread. Example: `thread_abc123`. Leave blank to create a new thread. To locate the thread ID, make sure your OpenAI Threads setting (Settings -> Organization/Personal -> General -> Features and capabilities -> Threads) is set to \"Visible to organization owners\" or \"Visible to everyone\". You can then access the list of threads and click on individual threads to reveal their IDs",
+      optional: true,
+    },
+    ...common.props,
+  },
+  async run({ $ }) {
+    // create assistant if not provided
+    let assistantId = this.assistantId;
+    if (!assistantId) {
+      const { id: newAssistantId } = await this.openai.createAssistant({
+        $,
+        data: {
+          model: this.model,
+          name: this.name,
+          instructions: this.instructions,
+          tools: this.buildTools(),
+          tool_resources: this.buildToolResources(),
+        },
+      });
+      assistantId = newAssistantId;
+    }
+
+    // create and run thread if no thread is provided
+    let threadId = this.threadId;
+    let run;
+    if (!threadId) {
+      run = await this.openai.createThreadAndRun({
+        $,
+        data: {
+          assistant_id: assistantId,
+          thread: {
+            messages: [
+              {
+                role: "user",
+                content: this.message,
+              },
+            ],
+          },
+          model: this.model,
+          instructions: this.instructions,
+          tools: this.buildTools(),
+          tool_resources: this.buildToolResources(),
+        },
+      });
+      threadId = run.thread_id;
+    } else {
+      // create run for thread if threadId is provided
+      run = await this.openai.createRun({
+        $,
+        threadId: this.threadId,
+        data: {
+          assistant_id: assistantId,
+          model: this.model,
+          instructions: this.instructions,
+          tools: this.buildTools(),
+          tool_resources: this.buildToolResources(),
+          additional_messages: [
+            {
+              role: "user",
+              content: this.message,
+            },
+          ],
+        },
+      });
+    }
+    const runId = run.id;
+
+    run = await this.pollRunUntilCompleted(run, threadId, runId, $);
+
+    // get response;
+    const { data: messages } = await this.openai.listMessages({
+      $,
+      threadId,
+      params: {
+        order: "desc",
+      },
+    });
+    const response = messages[0].content[0].text.value;
+    return {
+      response,
+      messages,
+      run,
+    };
+  },
+};

package/actions/classify-items-into-categories/classify-items-into-categories.mjs

@@ -3,12 +3,22 @@ import common from "../common/common-helper.mjs";
 export default {
   ...common,
   name: "Classify Items into Categories",
-  version: "0.0.10",
+  version: "0.0.11",
   key: "openai-classify-items-into-categories",
-  description: "Classify items into specific categories using the Chat API",
+  description: "Classify items into specific categories using the Chat API. [See the documentation](https://platform.openai.com/docs/api-reference/chat)",
   type: "action",
   props: {
     ...common.props,
+    info: {
+      type: "alert",
+      alertType: "info",
+      content: `Provide a list of **items** and a list of **categories**. The output will contain an array of objects, each with properties \`item\` and \`category\`
+        \nExample:
+        \nIf **Categories** is \`["people", "pets"]\`, and **Items** is \`["dog", "George Washington"]\`
+        \n The output will contain the following categorizations:
+        \n \`[{"item":"dog","category":"pets"},{"item":"George Washington","category":"people"}]\`
+      `,
+    },
     items: {
       label: "Items",
       description: "Items to categorize",
@@ -40,17 +50,24 @@ export default {
       if (!messages || !response) {
         throw new Error("Invalid API output, please reach out to https://pipedream.com/support");
       }
-      const assistantResponse = response.choices?.[0]?.message?.content;
-      let categorizations = assistantResponse;
-      try {
-        categorizations = JSON.parse(assistantResponse);
-      } catch (err) {
-        console.log("Failed to parse output, assistant returned malformed JSON");
+      const responses = response.choices?.map(({ message }) => message.content);
+      const categorizations = [];
+      for (const response of responses) {
+        try {
+          categorizations.push(JSON.parse(response));
+        } catch (err) {
+          console.log("Failed to parse output, assistant returned malformed JSON");
+        }
       }
-      return {
-        categorizations,
+      const output = {
         messages,
       };
+      if (this.n > 1) {
+        output.categorizations = categorizations;
+      } else {
+        output.categorizations = categorizations[0];
+      }
+      return output;
     },
   },
 };

package/actions/common/common-assistants.mjs

@@ -0,0 +1,128 @@
+import constants from "../../common/constants.mjs";
+
+export default {
+  props: {
+    toolTypes: {
+      type: "string[]",
+      label: "Tool Types",
+      description: "The types of tools to enable on the assistant",
+      options: constants.TOOL_TYPES,
+      optional: true,
+      reloadProps: true,
+    },
+  },
+  async additionalProps() {
+    const props = {};
+    if (!this.toolTypes?.length) {
+      return props;
+    }
+    return this.getToolProps();
+  },
+  methods: {
+    async getToolProps() {
+      const props = {};
+      if (this.toolTypes.includes("code_interpreter")) {
+        props.fileIds = {
+          type: "string[]",
+          label: "File IDs",
+          description: "List of file IDs to attach to the message",
+          optional: true,
+          options: async () => {
+            const { data } = await this.openai.listFiles({
+              purpose: "assistants",
+            });
+            return data?.map(({
+              filename, id,
+            }) => ({
+              label: filename,
+              value: id,
+            })) || [];
+          },
+        };
+      }
+      if (this.toolTypes.includes("file_search")) {
+        props.vectorStoreIds = {
+          type: "string[]",
+          label: "Vector Store IDs",
+          description: "The ID of the vector store to attach to this assistant",
+          optional: true,
+          options: async () => {
+            const { data } = await this.openai.listVectorStores();
+            return data?.map(({
+              name, id,
+            }) => ({
+              label: name,
+              value: id,
+            })) || [];
+          },
+        };
+      }
+      if (this.toolTypes.includes("function")) {
+        props.functionName = {
+          type: "string",
+          label: "Function Name",
+          description: "The name of the function to be called. Must be a-z, A-Z, 0-9, or contain underscores and dashes, with a maximum length of 64.",
+        };
+        props.functionDescription = {
+          type: "string",
+          label: "Function Description",
+          description: "A description of what the function does, used by the model to choose when and how to call the function.",
+          optional: true,
+        };
+        props.functionParameters = {
+          type: "object",
+          label: "Function Parameters",
+          description: "The parameters the functions accepts, described as a JSON Schema object. See the [guide](https://platform.openai.com/docs/guides/text-generation/function-calling) for examples, and the [JSON Schema reference](https://json-schema.org/understanding-json-schema/) for documentation about the format.",
+          optional: true,
+        };
+      }
+      return props;
+    },
+    buildTools() {
+      const tools = this.toolTypes?.filter((toolType) => toolType !== "function")?.map((toolType) => ({
+        type: toolType,
+      })) || [];
+      if (this.toolTypes?.includes("function")) {
+        tools.push({
+          type: "function",
+          function: {
+            name: this.functionName,
+            description: this.functionDescription,
+            parameters: this.functionParameters,
+          },
+        });
+      }
+      return tools.length
+        ? tools
+        : undefined;
+    },
+    buildToolResources() {
+      const toolResources = {};
+      if (this.toolTypes?.includes("code_interpreter") && this.fileIds?.length) {
+        toolResources.code_interpreter = {
+          file_ids: this.fileIds,
+        };
+      }
+      if (this.toolTypes?.includes("file_search") && this.vectorStoreIds?.length) {
+        toolResources.file_search = {
+          vector_store_ids: this.vectorStoreIds,
+        };
+      }
+      return Object.keys(toolResources).length
+        ? toolResources
+        : undefined;
+    },
+    async pollRunUntilCompleted(run, threadId, runId, $ = this) {
+      const timer = (ms) => new Promise((res) => setTimeout(res, ms));
+      while (run.status === "queued" || run.status === "in_progress") {
+        run = await this.openai.retrieveRun({
+          $,
+          threadId,
+          runId,
+        });
+        await timer(3000);
+      }
+      return run;
+    },
+  },
+};

package/actions/common/common-helper.mjs

@@ -5,6 +5,13 @@ export default {
   ...common,
   props: {
     openai,
+    modelId: {
+      propDefinition: [
+        openai,
+        "chatCompletionModelId",
+      ],
+      description: "The ID of the model to use for chat completions",
+    },
     ...common.props,
   },
   methods: {
@@ -33,14 +40,14 @@ export default {
         content: this.userMessage(),
       },
     ];
-    const args = {
+    const data = {
       ...this._getCommonArgs(),
-      model: "gpt-3.5-turbo",
+      model: this.modelId,
       messages,
     };
     const response = await this.openai.createChatCompletion({
       $,
-      args,
+      data,
     });
 
     if (this.summary() && response) {

package/actions/{create-speech/create-speech.mjs → convert-text-to-speech/convert-text-to-speech.mjs}

@@ -2,10 +2,10 @@ import fs from "fs";
 import openai from "../../openai.app.mjs";
 
 export default {
-  key: "openai-create-speech",
-  name: "Create Speech (TTS)",
+  key: "openai-convert-text-to-speech",
+  name: "Convert Text to Speech (TTS)",
   description: "Generates audio from the input text. [See the documentation](https://platform.openai.com/docs/api-reference/audio/createSpeech)",
-  version: "0.0.5",
+  version: "0.0.6",
   type: "action",
   props: {
     openai,