Leonardo components

components/leonardo_ai/README.md

@@ -0,0 +1,14 @@
+# Leonardo AI
+
+[Leonardo AI](https://leonardo.ai) is an AI-powered image generation platform that allows you to create stunning images, videos, and 3D models using advanced machine learning models.
+
+## API Reference
+
+For detailed information about Leonardo AI's API, visit the [official documentation](https://docs.leonardo.ai/reference).
+
+## Support
+
+For support with this component or Leonardo AI's API, please refer to:
+- [Leonardo AI Documentation](https://docs.leonardo.ai)
+- [Leonardo AI Community](https://community.leonardo.ai)
+- [Pipedream Support](https://pipedream.com/support)

components/leonardo_ai/actions/generate-image/generate-image.mjs

@@ -0,0 +1,111 @@
+import app from "../../leonardo_ai.app.mjs";
+
+export default {
+  key: "leonardo_ai-generate-image",
+  name: "Generate Image",
+  description: "Generates new images using Leonardo AI's image generation API.  [See the documentation](https://docs.leonardo.ai/reference/creategeneration)",
+  version: "0.0.1",
+  type: "action",
+  props: {
+    app,
+    prompt: {
+      type: "string",
+      label: "Prompt",
+      description: "The text prompt describing the image you want to generate.",
+    },
+    modelId: {
+      type: "string",
+      label: "Model",
+      description: "The model to use for generation. Leave empty to use the default model.",
+      async options() {
+        const models = await this.app.getPlatformModels();
+        return models.map((model) => ({
+          label: model.name || model.id,
+          value: model.id,
+        }));
+      },
+      optional: true,
+    },
+    width: {
+      type: "integer",
+      label: "Width",
+      description: "Width of the generated image in pixels.",
+      default: 1024,
+      min: 32,
+      max: 1536,
+    },
+    height: {
+      type: "integer",
+      label: "Height",
+      description: "Height of the generated image in pixels.",
+      default: 768,
+      min: 32,
+      max: 1536,
+    },
+    numImages: {
+      type: "integer",
+      label: "Number of Images",
+      description: "Number of images to generate (1-8). If either width or height is over 768, must be between 1 and 4.",
+      default: 1,
+      min: 1,
+      max: 8,
+    },
+    guidanceScale: {
+      type: "integer",
+      label: "Guidance Scale",
+      description: "How closely the model should follow the prompt. Must be between 1 and 20. Higher values = more adherence to prompt.",
+      default: 7,
+      min: 1,
+      max: 20,
+      optional: true,
+    },
+    numInferenceSteps: {
+      type: "integer",
+      label: "Inference Steps",
+      description: "Number of denoising steps. More steps = higher quality but slower generation.",
+      default: 15,
+      min: 10,
+      max: 60,
+      optional: true,
+    },
+    seed: {
+      type: "integer",
+      label: "Seed",
+      description: "Random seed for reproducible generation. Leave empty for random generation.",
+      optional: true,
+    },
+  },
+  async run({ $ }) {
+    const {
+      prompt,
+      modelId,
+      width,
+      height,
+      numImages,
+      guidanceScale,
+      numInferenceSteps,
+      seed,
+    } = this;
+
+    const data = {
+      prompt,
+      width,
+      height,
+      num_images: numImages,
+      modelId,
+      guidance_scale: guidanceScale,
+      num_inference_steps: numInferenceSteps,
+      seed,
+    };
+
+    const response = await this.app._makeRequest({
+      $,
+      method: "POST",
+      path: "/generations",
+      data,
+    });
+
+    $.export("$summary", `Successfully generated ${numImages} image(s)`);
+    return response;
+  },
+};

components/leonardo_ai/actions/generate-motion/generate-motion.mjs

@@ -0,0 +1,117 @@
+import app from "../../leonardo_ai.app.mjs";
+
+export default {
+  key: "leonardo_ai-generate-motion",
+  name: "Generate Motion",
+  description: "Generates a motion (video) from the provided image using Leonardo AI's SVD Motion Generation API. [See the documentation](https://docs.leonardo.ai/reference/createsvdmotiongeneration)",
+  version: "0.0.1",
+  type: "action",
+  props: {
+    app,
+    imageId: {
+      type: "string",
+      label: "Image ID",
+      description: "The ID of the image to generate motion from. You can either select from previously generated images or manually enter the ID of an uploaded image.",
+      async options({ prevContext }) {
+        // Get user info to retrieve userId
+        const userInfo = await this.app.getUserInfo({
+          $: this,
+        });
+        // Extract userId from the response structure
+        const userId = userInfo.user_details?.[0]?.user?.id || userInfo.id;
+
+        // Get generations with pagination
+        const offset = prevContext?.offset || 0;
+        const limit = 20;
+
+        const generations = await this.app.getGenerationsByUserId({
+          $: this,
+          userId,
+          offset,
+          limit,
+        });
+
+        // Extract image IDs from generated_images array
+        const options = [];
+        if (generations.generations) {
+          for (const generation of generations.generations) {
+            if (generation.generated_images) {
+              for (const image of generation.generated_images) {
+                options.push({
+                  label: `Image ${image.id} (Generation ${generation.id})`,
+                  value: image.id,
+                });
+              }
+            }
+          }
+        }
+
+        // Check if there are more pages
+        const hasMore = generations.generations && generations.generations.length === limit;
+        const nextOffset = hasMore
+          ? offset + limit
+          : null;
+
+        return {
+          options,
+          context: nextOffset
+            ? {
+              offset: nextOffset,
+            }
+            : {},
+        };
+      },
+    },
+    motionStrength: {
+      type: "integer",
+      label: "Motion Strength",
+      description: "The motion strength for the video generation.",
+      optional: true,
+    },
+    isPublic: {
+      type: "boolean",
+      label: "Is Public",
+      description: "Whether the generation is public or not.",
+      optional: true,
+    },
+    isInitImage: {
+      type: "boolean",
+      label: "Is Init Image",
+      description: "Whether the image being used is an init image uploaded by the user.",
+      optional: true,
+    },
+    isVariation: {
+      type: "boolean",
+      label: "Is Variation",
+      description: "Whether the image being used is a variation image.",
+      optional: true,
+    },
+  },
+  async run({ $ }) {
+    const {
+      imageId,
+      motionStrength,
+      isPublic,
+      isInitImage,
+      isVariation,
+    } = this;
+
+    const data = {
+      imageId,
+      motionStrength,
+      isPublic,
+      isInitImage,
+      isVariation,
+    };
+
+    const response = await this.app._makeRequest({
+      $,
+      method: "POST",
+      path: "/generations-motion-svd",
+      data,
+    });
+
+    $.export("$summary", `Successfully generated motion from image ID: ${imageId}`);
+    return response;
+  },
+};

components/leonardo_ai/actions/unzoom-image/unzoom-image.mjs

@@ -0,0 +1,44 @@
+import app from "../../leonardo_ai.app.mjs";
+
+export default {
+  key: "leonardo_ai-unzoom-image",
+  name: "Unzoom Image",
+  description: "Creates an unzoom variation for a generated or variation image using Leonardo AI's unzoom API. [See the documentation](https://docs.leonardo.ai/reference/createvariationunzoom)",
+  version: "0.0.1",
+  type: "action",
+  props: {
+    app,
+    imageId: {
+      type: "string",
+      label: "Image ID",
+      description: "The ID of the image to create an unzoom variation for. This should be a previously generated or variation image ID.",
+    },
+    isVariation: {
+      type: "boolean",
+      label: "Is Variation",
+      description: "Whether the image is a variation image.",
+      default: false,
+    },
+  },
+  async run({ $ }) {
+    const {
+      imageId,
+      isVariation,
+    } = this;
+
+    const data = {
+      id: imageId,
+      isVariation,
+    };
+
+    const response = await this.app._makeRequest({
+      $,
+      method: "POST",
+      path: "/variations/unzoom",
+      data,
+    });
+
+    $.export("$summary", `Successfully created unzoom variation for image ID: ${imageId}`);
+    return response;
+  },
+};

components/leonardo_ai/actions/upload-image/upload-image.mjs

@@ -0,0 +1,96 @@
+import app from "../../leonardo_ai.app.mjs";
+import FormData from "form-data";
+import { getFileStreamAndMetadata } from "@pipedream/platform";
+
+export default {
+  key: "leonardo_ai-upload-image",
+  name: "Upload Image",
+  description: "Uploads a new image to Leonardo AI for use in generations and variations. [See the documentation](https://docs.leonardo.ai/docs/how-to-upload-an-image-using-a-presigned-url)",
+  version: "0.0.1",
+  type: "action",
+  props: {
+    app,
+    extension: {
+      type: "string",
+      label: "File Extension",
+      description: "The file extension of the image to upload.",
+      options: [
+        {
+          label: "PNG",
+          value: "png",
+        },
+        {
+          label: "JPG",
+          value: "jpg",
+        },
+        {
+          label: "JPEG",
+          value: "jpeg",
+        },
+        {
+          label: "WebP",
+          value: "webp",
+        },
+      ],
+    },
+    filePath: {
+      type: "string",
+      label: "File Path or URL",
+      description: "The file to upload. Provide either a file URL or a path to a file in the `/tmp` directory (for example, `/tmp/myImage.png`)",
+    },
+    syncDir: {
+      type: "dir",
+      accessMode: "read",
+      sync: true,
+      optional: true,
+    },
+  },
+  async run({ $ }) {
+    const {
+      extension,
+      filePath,
+    } = this;
+    // Get file stream from URL or /tmp based path
+    const {
+      stream,
+      metadata,
+    } = await getFileStreamAndMetadata(filePath);
+
+    // Step 1: Get the presigned URL, upload fields appended to formData
+    const uploadResponse = await this.app.getUploadInitImage({
+      $,
+      extension,
+    });
+
+    const { uploadInitImage } = uploadResponse;
+    const fields = JSON.parse(uploadInitImage.fields);
+    const formData = new FormData();
+
+    //Important: Order of fields is sanctioned by Leonardo AI API. Fields go first, then the file
+    for (const [
+      label,
+      value,
+    ] of Object.entries(fields)) {
+      formData.append(label, value.toString());
+    }
+    formData.append("file", stream, {
+      contentType: metadata.contentType,
+      knownLength: metadata.size,
+      filename: metadata.name,
+    });
+    const uploadUrl = uploadInitImage.url;
+
+    // Step 2: Upload the file to the presigned URL
+    const uploadResult = await this.app.uploadFileToPresignedUrl({
+      $,
+      url: uploadUrl,
+      formData,
+    });
+
+    $.export("$summary", `Successfully uploaded image: ${metadata.name || filePath}`);
+    return {
+      uploadInitImage,
+      uploadResult,
+    };
+  },
+};