@rohitaryal/whisk-api 3.2.0 → 4.0.1

package/README.md

@@ -16,11 +16,12 @@ bun i -g @rohitaryal/whisk-api
 ## Features
 
 1. Text to Image using `IMAGEN_3_5`
-2. Image to Video (Animation) using `VEO`
-3. Image Refinement (Editing/Inpainting using NanoBanana)
-4. Image to Text
+2. Image to Video (Animation) using `VEO_3_1`
+3. Image Refinement (Editing/Inpainting)
+4. Image to Text (Caption Generation)
 5. Project & Media Management
-6. Command line support
+6. Upload & Reference Images
+7. Command line support
 
 ## Usage
 
@@ -62,6 +63,12 @@ Make sure you have:
 > - PowerShell: `"$env:COOKIE"`
 > - Command Prompt: `"%COOKIE%"`
 
+- Creating a new project
+
+    ```bash
+    whisk project --name "My Project" --cookie "$COOKIE"
+    ```
+
 - Generating image with prompt
 
     ```bash
@@ -95,55 +102,164 @@ Make sure you have:
     whisk caption --file /path/to/img.webp --count 3 --cookie "$COOKIE"
     ```
 
+- Fetching an existing media by ID
+
+    ```bash
+    whisk fetch "__MEDIA__ID__HERE__" --cookie "$COOKIE"
+    ```
+
+- Uploading an image as reference
+
+    ```bash
+    whisk upload /path/to/image.jpg --category SUBJECT --project "__PROJECT__ID__" --cookie "$COOKIE"
+    ```
+
 - Deleting media from the cloud
 
     ```bash
     whisk delete "__MEDIA__ID__HERE__" --cookie "$COOKIE"
     ```
 
-Full generation help:
+Full CLI commands help:
 
 ```text
-whisk generate <options>
+whisk <cmd> [args]
+
+Commands:
+  whisk project             Generate a new project
+  whisk generate            Generate new images using a temporary project
+  whisk animate <mediaId>   Animate an existing landscape image into a video
+  whisk refine <mediaId>    Edit/Refine an existing image
+  whisk caption             Generate captions for a local image file
+  whisk fetch <mediaId>     Download an existing generated media by ID
+  whisk upload <file>       Upload an image to be used as reference later
+  whisk delete <mediaId>    Delete a generated media from the cloud
 
 Options:
-      --version     Show version number
-  -h, --help        Show help
-  -p, --prompt      Description of the image
-  -m, --model       Image generation model (Default: IMAGEN_3_5)
-  -a, --aspect      Aspect ratio (SQUARE, PORTRAIT, LANDSCAPE)
-  -s, --seed        Seed value (0 for random)
-  -d, --dir         Output directory
-  -c, --cookie      Google account cookie
+  -c, --cookie  Google account cookie [required]
+  -h, --help    Show help
+      --version Show version number
 ```
 
-Full animation help:
+<details>
+<summary>Project Command</summary>
+
+```text
+whisk project
+
+Options:
+  --name        Project name [default: "Whisk-CLI project"]
+  -c, --cookie  Google account cookie [required]
+```
+</details>
+
+<details>
+<summary>Generate Command</summary>
+
+```text
+whisk generate
+
+Options:
+  -p, --prompt   Description of the image [required]
+  -m, --model    Image generation model [default: "IMAGEN_3_5"]
+  -a, --aspect   Aspect ratio (SQUARE, PORTRAIT, LANDSCAPE) [default: "LANDSCAPE"]
+  -s, --seed     Seed value (0 for random) [default: 0]
+  -d, --dir      Output directory [default: "./output"]
+  -c, --cookie   Google account cookie [required]
+```
+</details>
+
+<details>
+<summary>Animate Command</summary>
 
 ```text
 whisk animate <mediaId>
 
 Positionals:
-  mediaId  The ID of the image to animate
+  mediaId  The ID of the image to animate [required]
+
+Options:
+  -s, --script   Prompt/Script for the video animation [required]
+  -m, --model    Video generation model [default: "VEO_3_1"]
+  -d, --dir      Output directory [default: "./output"]
+  -c, --cookie   Google account cookie [required]
+```
+</details>
+
+<details>
+<summary>Refine Command</summary>
+
+```text
+whisk refine <mediaId>
+
+Positionals:
+  mediaId  The ID of the image to refine [required]
+
+Options:
+  -p, --prompt   Instruction for editing (e.g., 'Make it snowy') [required]
+  -d, --dir      Output directory [default: "./output"]
+  -c, --cookie   Google account cookie [required]
+```
+</details>
+
+<details>
+<summary>Caption Command</summary>
+
+```text
+whisk caption
 
 Options:
-  -s, --script    Prompt/Script for the video animation
-  -m, --model     Video generation model (Default: VEO_FAST_3_1)
-  -d, --dir       Output directory
-  -c, --cookie    Google account cookie
+  -f, --file     Path to local image file [required]
+  -n, --count    Number of captions [default: 1]
+  -c, --cookie   Google account cookie [required]
 ```
+</details>
 
-Full fetch help:
+<details>
+<summary>Fetch Command</summary>
 
 ```text
 whisk fetch <mediaId>
 
 Positionals:
-  mediaId  Unique ID of generated media
+  mediaId  Unique ID of generated media [required]
 
 Options:
-  -d, --dir      Output directory
-  -c, --cookie   Google account cookie
+  -d, --dir      Output directory [default: "./output"]
+  -c, --cookie   Google account cookie [required]
 ```
+</details>
+
+<details>
+<summary>Upload Command</summary>
+
+```text
+whisk upload <file>
+
+Positionals:
+  file  Path to local image file [required]
+
+Options:
+  --category, -ca  Category of reference [required]
+                   Choices: SUBJECT, SCENE, STYLE
+  --project, -pr   Project/Workflow ID [required]
+  -c, --cookie     Google account cookie [required]
+```
+</details>
+
+<details>
+<summary>Delete Command</summary>
+
+```text
+whisk delete <mediaId>
+
+Positionals:
+  mediaId  Unique ID of generated media to delete [required]
+
+Options:
+  -c, --cookie   Google account cookie [required]
+```
+</details>
 
 </details>
 
@@ -186,7 +302,7 @@ Options:
     const refinedImage = await baseImage.refine("Make it raining neon rain");
 
     // 3. Animate (Video)
-    const video = await refinedImage.animate("Camera flies through the streets", "VEO_FAST_3_1");
+    const video = await refinedImage.animate("Camera flies through the streets", "VEO_3_1_I2V_12STEP");
 
     video.save("./videos");
     ```

package/dist/Cli.js

@@ -3,11 +3,33 @@ import yargs from "yargs";
 import { hideBin } from 'yargs/helpers';
 import { Whisk } from "./Whisk.js";
 import { imageToBase64 } from "./Utils.js";
-import { ImageAspectRatio, ImageGenerationModel, VideoGenerationModel } from "./Constants.js";
+import { ImageAspectRatio, ImageGenerationModel, MediaCategory, VideoGenerationModel } from "./Constants.js";
 const y = yargs(hideBin(process.argv));
 await y
     .scriptName("whisk")
     .usage('$0 <cmd> [args]')
+    .option("cookie", {
+    alias: "c",
+    describe: "Google account cookie",
+    type: "string",
+    demandOption: true,
+})
+    .command("project", "Generate a new project", (yargs) => {
+    return yargs
+        .option("name", {
+        describe: "Project name",
+        demandOption: false,
+        type: "string",
+        default: "Whisk-CLI project"
+    });
+}, async (argv) => {
+    const whisk = new Whisk(argv.cookie);
+    await whisk.account.refresh();
+    console.log(whisk.account.toString());
+    console.log("[*] Creating new project...");
+    const project = await whisk.newProject(argv.name);
+    console.log("[+] Project ID:", project.projectId);
+})
     .command("generate", "Generate new images using a temporary project", (yargs) => {
     return yargs
         .option("prompt", {
@@ -41,12 +63,6 @@ await y
         describe: "Output directory",
         type: "string",
         default: "./output",
-    })
-        .option("cookie", {
-        alias: "c",
-        describe: "Google account cookie",
-        type: "string",
-        demandOption: true,
     });
 }, async (argv) => {
     const whisk = new Whisk(argv.cookie);
@@ -91,7 +107,7 @@ await y
         alias: "m",
         describe: "Video generation model",
         type: "string",
-        default: "VEO_FAST_3_1",
+        default: "VEO_3_1",
         choices: Object.keys(VideoGenerationModel)
     })
         .option("dir", {
@@ -99,12 +115,6 @@ await y
         describe: "Output directory",
         type: "string",
         default: "./output",
-    })
-        .option("cookie", {
-        alias: "c",
-        describe: "Google account cookie",
-        type: "string",
-        demandOption: true,
     });
 }, async (argv) => {
     const whisk = new Whisk(argv.cookie);
@@ -141,12 +151,6 @@ await y
         describe: "Output directory",
         type: "string",
         default: "./output",
-    })
-        .option("cookie", {
-        alias: "c",
-        describe: "Google account cookie",
-        type: "string",
-        demandOption: true,
     });
 }, async (argv) => {
     const whisk = new Whisk(argv.cookie);
@@ -178,12 +182,6 @@ await y
         describe: "Number of captions",
         type: "number",
         default: 1
-    })
-        .option("cookie", {
-        alias: "c",
-        describe: "Google account cookie",
-        type: "string",
-        demandOption: true,
     });
 }, async (argv) => {
     const whisk = new Whisk(argv.cookie);
@@ -216,12 +214,6 @@ await y
         describe: "Output directory",
         type: "string",
         default: "./output",
-    })
-        .option("cookie", {
-        alias: "c",
-        describe: "Google account cookie",
-        type: "string",
-        demandOption: true,
     });
 }, async (argv) => {
     const whisk = new Whisk(argv.cookie);
@@ -237,16 +229,43 @@ await y
         console.error("[!] Fetch failed:", error);
     }
 })
-    .command("delete <mediaId>", "Delete a generated media from the cloud", (yargs) => {
+    .command("upload <file>", "Upload an image to be used as reference later. References can't be used currently", (yargs) => {
     return yargs
-        .positional("mediaId", {
-        describe: "Unique ID of generated media to delete",
+        .positional("file", {
+        describe: "Path to local image file",
+        type: "string",
+        demandOption: true
+    })
+        .option("category", {
+        alias: "ca",
+        describe: "Category of reference",
         type: "string",
         demandOption: true,
+        choices: Object.keys(MediaCategory)
     })
-        .option("cookie", {
-        alias: "c",
-        describe: "Google account cookie",
+        .option("project", {
+        alias: "pr",
+        describe: "Project/Workflow ID",
+        type: "string",
+        demandOption: true
+    });
+}, async (argv) => {
+    const whisk = new Whisk(argv.cookie);
+    await whisk.account.refresh();
+    console.log(whisk.account.toString());
+    console.log("[*] Generating caption for image...");
+    const base64 = await imageToBase64(argv.file);
+    // Split at the comma to get the raw base64 string
+    const rawBase64 = base64.split(",")[1];
+    const captionedImage = await Whisk.generateCaption(rawBase64, whisk.account);
+    console.log("[*] Uploading image...");
+    let mediaId = await Whisk.uploadImage(rawBase64, captionedImage[0], MediaCategory[argv.category], argv.project, whisk.account);
+    console.log("[+] ID:", mediaId);
+})
+    .command("delete <mediaId>", "Delete a generated media from the cloud", (yargs) => {
+    return yargs
+        .positional("mediaId", {
+        describe: "Unique ID of generated media to delete",
         type: "string",
         demandOption: true,
     });

package/dist/Constants.d.ts

@@ -33,5 +33,9 @@ export declare const ImageRefinementModel: Readonly<{
 }>;
 export declare const VideoGenerationModel: Readonly<{
     readonly VEO_3_1: "VEO_3_1_I2V_12STEP";
-    readonly VEO_FAST_3_1: "veo_3_1_i2v_s_fast";
+}>;
+export declare const MediaCategory: Readonly<{
+    readonly SUBJECT: "MEDIA_CATEGORY_SUBJECT";
+    readonly SCENE: "MEDIA_CATEGORY_SCENE";
+    readonly STYLE: "MEDIA_CATEGORY_STYLE";
 }>;

package/dist/Constants.js

@@ -33,5 +33,11 @@ export const ImageRefinementModel = Object.freeze({
 });
 export const VideoGenerationModel = Object.freeze({
     VEO_3_1: "VEO_3_1_I2V_12STEP",
-    VEO_FAST_3_1: "veo_3_1_i2v_s_fast",
+    // https://github.com/rohitaryal/whisk-api/issues/13
+    // VEO_FAST_3_1: "veo_3_1_i2v_s_fast",
+});
+export const MediaCategory = Object.freeze({
+    SUBJECT: "MEDIA_CATEGORY_SUBJECT",
+    SCENE: "MEDIA_CATEGORY_SCENE",
+    STYLE: "MEDIA_CATEGORY_STYLE",
 });

package/dist/Media.js

@@ -150,21 +150,23 @@ export class Media {
             // Await for 2 second before each request
             await new Promise(resolve => setTimeout(resolve, 2000));
             if (videoResults.status === "MEDIA_GENERATION_STATUS_SUCCESSFUL") {
-                const video = videoResults.operation.metadata.video;
+                const video = videoResults.operations[0].operation.metadata.video;
                 return new Media({
                     seed: video.seed,
                     prompt: video.prompt,
                     workflowId: this.workflowId,
-                    encodedMedia: videoResults.rawBytes,
-                    mediaGenerationId: videoResults.mediaGenerationId,
+                    encodedMedia: videoResults.operations[0].rawBytes,
+                    mediaGenerationId: videoResults.operations[0].mediaGenerationId,
                     aspectRatio: video.aspectRatio,
                     mediaType: "VIDEO",
                     model: video.model,
                     account: this.account,
                 });
             }
-            if (i >= 20) {
-                throw new Error("failed to generate video: " + videoResults);
+            // Wait for few more time
+            // https://github.com/rohitaryal/whisk-api/issues/4
+            if (i >= 60) {
+                throw new Error("failed to generate video: " + JSON.stringify(videoResults));
             }
         }
     }

package/dist/Project.d.ts

@@ -1,13 +1,40 @@
 import { Media } from "./Media.js";
-import type { PromptConfig } from "./Types.js";
+import type { ImageInput, MediaReference, PromptConfig } from "./Types.js";
 import { Account } from "./Whisk.js";
 export declare class Project {
     readonly account: Account;
     readonly projectId: string;
-    readonly subjects: Media[];
-    readonly scenes: Media[];
-    readonly styles: Media[];
+    readonly subjects: MediaReference[];
+    readonly scenes: MediaReference[];
+    readonly styles: MediaReference[];
     constructor(projectId: string, account: Account);
+    /**
+     * Uploads a custom image and adds it as a subject reference
+     *
+     * @param input Image as { file: string }, { url: string }, or { base64: string }
+     */
+    addSubject(input: ImageInput): Promise<MediaReference>;
+    /**
+     * Uploads a custom image and adds it as a scene reference
+     *
+     * @param input Image as { file: string }, { url: string }, or { base64: string }
+     */
+    addScene(input: ImageInput): Promise<MediaReference>;
+    /**
+     * Uploads a custom image and adds it as a style reference
+     *
+     * @param input Image as { file: string }, { url: string }, or { base64: string }
+     */
+    addStyle(input: ImageInput): Promise<MediaReference>;
+    addSubjectById(mediaGenerationId: string, prompt: string): void;
+    addSceneById(mediaGenerationId: string, prompt: string): void;
+    addStyleById(mediaGenerationId: string, prompt: string): void;
+    removeSubject(mediaGenerationId: string): MediaReference;
+    removeScene(mediaGenerationId: string): MediaReference;
+    removeStyle(mediaGenerationId: string): MediaReference;
+    private addById;
+    private removeById;
+    private addReference;
     generateImage(input: string | PromptConfig): Promise<Media>;
     /**
      * Generate image but with subject, scene, style attached

package/dist/Project.js

@@ -1,7 +1,7 @@
-import { ImageGenerationModel } from "./Constants.js";
+import { ImageGenerationModel, MediaCategory } from "./Constants.js";
 import { Media } from "./Media.js";
-import { request } from "./Utils.js";
-import { Account } from "./Whisk.js";
+import { request, resolveImageInput } from "./Utils.js";
+import { Account, Whisk } from "./Whisk.js";
 export class Project {
     account;
     projectId;
@@ -21,6 +21,98 @@ export class Project {
         this.scenes = [];
         this.styles = [];
     }
+    /**
+     * Uploads a custom image and adds it as a subject reference
+     *
+     * @param input Image as { file: string }, { url: string }, or { base64: string }
+     */
+    async addSubject(input) {
+        return this.addReference(input, MediaCategory.SUBJECT, this.subjects);
+    }
+    /**
+     * Uploads a custom image and adds it as a scene reference
+     *
+     * @param input Image as { file: string }, { url: string }, or { base64: string }
+     */
+    async addScene(input) {
+        return this.addReference(input, MediaCategory.SCENE, this.scenes);
+    }
+    /**
+     * Uploads a custom image and adds it as a style reference
+     *
+     * @param input Image as { file: string }, { url: string }, or { base64: string }
+     */
+    async addStyle(input) {
+        return this.addReference(input, MediaCategory.STYLE, this.styles);
+    }
+    addSubjectById(mediaGenerationId, prompt) {
+        this.addById(mediaGenerationId, prompt, this.subjects);
+    }
+    addSceneById(mediaGenerationId, prompt) {
+        this.addById(mediaGenerationId, prompt, this.scenes);
+    }
+    addStyleById(mediaGenerationId, prompt) {
+        this.addById(mediaGenerationId, prompt, this.styles);
+    }
+    removeSubject(mediaGenerationId) {
+        return this.removeById(mediaGenerationId, this.subjects);
+    }
+    removeScene(mediaGenerationId) {
+        return this.removeById(mediaGenerationId, this.scenes);
+    }
+    removeStyle(mediaGenerationId) {
+        return this.removeById(mediaGenerationId, this.styles);
+    }
+    addById(mediaGenerationId, prompt, target) {
+        if (typeof mediaGenerationId !== "string" || !mediaGenerationId.trim()) {
+            throw new Error("media generation id is required");
+        }
+        if (typeof prompt !== "string" || !prompt.trim()) {
+            throw new Error("prompt is required");
+        }
+        if (target.some(ref => ref.mediaGenerationId === mediaGenerationId)) {
+            throw new Error(`'${mediaGenerationId}': reference already exists`);
+        }
+        target.push({ prompt, mediaGenerationId });
+    }
+    removeById(mediaGenerationId, target) {
+        if (typeof mediaGenerationId !== "string" || !mediaGenerationId.trim()) {
+            throw new Error("media generation id is required");
+        }
+        const index = target.findIndex(ref => ref.mediaGenerationId === mediaGenerationId);
+        if (index === -1) {
+            throw new Error(`'${mediaGenerationId}': reference not found`);
+        }
+        return target.splice(index, 1)[0];
+    }
+    async addReference(input, category, target) {
+        const rawBytes = await resolveImageInput(input);
+        if (!(rawBytes?.trim?.())) {
+            throw new Error("image data is required");
+        }
+        const captions = await request("https://labs.google/fx/api/trpc/backbone.captionImage", {
+            headers: { cookie: this.account.getCookie() },
+            body: JSON.stringify({
+                "json": {
+                    "clientContext": {
+                        "workflowId": this.projectId
+                    },
+                    "captionInput": {
+                        "candidatesCount": 1,
+                        "mediaInput": {
+                            "mediaCategory": category,
+                            "rawBytes": rawBytes
+                        }
+                    }
+                }
+            })
+        });
+        const caption = captions.candidates[0].output;
+        const uploadMediaGenerationId = await Whisk.uploadImage(rawBytes, caption, category, this.projectId, this.account);
+        const ref = { prompt: caption, mediaGenerationId: uploadMediaGenerationId };
+        target.push(ref);
+        return ref;
+    }
     async generateImage(input) {
         if (typeof input === "string") {
             input = {

package/dist/Types.d.ts

@@ -1,5 +1,5 @@
 import type { Account } from "./Whisk.js";
-import { ImageAspectRatio, VideoAspectRatio, ImageExtension, ImageGenerationModel, VideoGenerationModel, ImageRefinementModel } from "./Constants.js";
+import { ImageAspectRatio, VideoAspectRatio, ImageExtension, ImageGenerationModel, VideoGenerationModel, ImageRefinementModel, MediaCategory } from "./Constants.js";
 export interface MediaConfig {
     seed: number;
     prompt: string;
@@ -24,3 +24,15 @@ export type ImageExtensionTypes = typeof ImageExtension[keyof typeof ImageExtens
 export type ImageGenerationModelType = typeof ImageGenerationModel[keyof typeof ImageGenerationModel];
 export type VideoGenerationModelType = typeof VideoGenerationModel[keyof typeof VideoGenerationModel];
 export type ImageRefinementModelType = typeof ImageRefinementModel[keyof typeof ImageRefinementModel];
+export type MediaCategoryType = typeof MediaCategory[keyof typeof MediaCategory];
+export interface MediaReference {
+    prompt: string;
+    mediaGenerationId: string;
+}
+export type ImageInput = {
+    file: string;
+} | {
+    url: string;
+} | {
+    base64: string;
+};

package/dist/Utils.d.ts

@@ -1,4 +1,4 @@
-import type { ImageExtensionTypes } from "./Types.js";
+import type { ImageInput } from "./Types.js";
 /**
  * Make a request, thats all
  *
@@ -7,9 +7,10 @@ import type { ImageExtensionTypes } from "./Types.js";
  */
 export declare function request<T>(input: RequestInfo | URL, init?: RequestInit): Promise<T>;
 /**
- * Returns base64 encoded image
+ * Fetches an image from a URL and returns base64 encoded string
  *
- * @param imagePath Path to image file
- * @param imageType Extension of image (if that matters)
+ * @param url URL of the image to fetch
  */
-export declare function imageToBase64(imagePath: string, imageType?: ImageExtensionTypes): Promise<string>;
+export declare function imageFromUrl(url: string): Promise<string>;
+export declare function resolveImageInput(input: ImageInput): Promise<string>;
+export declare function imageToBase64(imagePath: string): Promise<string>;

package/dist/Utils.js

@@ -20,22 +20,40 @@ export async function request(input, init) {
     return (json.result?.data?.json?.result || json);
 }
 /**
- * Returns base64 encoded image
+ * Fetches an image from a URL and returns base64 encoded string
  *
- * @param imagePath Path to image file
- * @param imageType Extension of image (if that matters)
+ * @param url URL of the image to fetch
  */
-export async function imageToBase64(imagePath, imageType) {
+export async function imageFromUrl(url) {
+    if (!(url?.trim?.())) {
+        throw new Error("url is required");
+    }
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`Failed to fetch image (${response.status}): ${url}`);
+    }
+    const contentType = response.headers.get("content-type") || "";
+    const imageType = contentType.split("/")[1]?.split(";")[0];
+    if (!Object.values(ImageExtension).includes(imageType)) {
+        throw new Error(`'${url}': unsupported image type '${contentType}'`);
+    }
+    const buffer = Buffer.from(await response.arrayBuffer());
+    return `data:image/${imageType};base64,${buffer.toString("base64")}`;
+}
+export async function resolveImageInput(input) {
+    if ("file" in input)
+        return await imageToBase64(input.file);
+    if ("url" in input)
+        return await imageFromUrl(input.url);
+    return input.base64;
+}
+export async function imageToBase64(imagePath) {
     if (!(imagePath?.trim?.()) || !fs.existsSync(imagePath)) {
         throw new Error(`'${imagePath}': image not found`);
     }
-    // Try to figure out image type from its extension
-    if (!(imageType?.trim?.())) {
-        imageType = path.extname(imagePath).slice(1);
-    }
-    // If extension not in valid extension list throw error
+    const imageType = path.extname(imagePath).slice(1);
     if (!Object.values(ImageExtension).includes(imageType)) {
-        throw new Error(`'${imagePath}': couldn't identify image type, please specify 'imageType'`);
+        throw new Error(`'${imagePath}': unsupported image type '${imageType}'`);
     }
     const base64Header = `data:image/${imageType};base64,`;
     return new Promise((resolve, reject) => {

package/dist/Whisk.d.ts

@@ -1,6 +1,6 @@
 import { Media } from "./Media.js";
 import { Project } from "./Project.js";
-import { PromptConfig } from "./Types.js";
+import { MediaCategoryType, PromptConfig } from "./Types.js";
 export declare class Account {
     private cookie;
     private authToken?;
@@ -32,6 +32,16 @@ export declare class Whisk {
      * @param count Number of captions to generate (min: 0, max: 8)
      */
     static generateCaption(input: string, account: Account, count?: number): Promise<string[]>;
+    /**
+     * Upload a custom image to Whisk's storage
+     *
+     * @param rawBytes Base64 encoded image
+     * @param caption Caption describing the image
+     * @param category Media category (SUBJECT, SCENE, or STYLE)
+     * @param workflowId Project workflow id
+     * @param account Account{} object
+     */
+    static uploadImage(rawBytes: string, caption: string, category: MediaCategoryType, workflowId: string, account: Account): Promise<string>;
     /**
      * Tries to get media from their unique id
      *

package/dist/Whisk.js

@@ -113,6 +113,42 @@ export class Whisk {
         });
         return captionResults.candidates.map(item => item.output);
     }
+    /**
+     * Upload a custom image to Whisk's storage
+     *
+     * @param rawBytes Base64 encoded image
+     * @param caption Caption describing the image
+     * @param category Media category (SUBJECT, SCENE, or STYLE)
+     * @param workflowId Project workflow id
+     * @param account Account{} object
+     */
+    static async uploadImage(rawBytes, caption, category, workflowId, account) {
+        if (!(rawBytes?.trim?.())) {
+            throw new Error("image data is required");
+        }
+        if (!(caption?.trim?.())) {
+            throw new Error("caption is required");
+        }
+        if (!(account instanceof Account)) {
+            throw new Error("invalid or missing account");
+        }
+        const uploadResult = await request("https://labs.google/fx/api/trpc/backbone.uploadImage", {
+            headers: { cookie: account.getCookie() },
+            body: JSON.stringify({
+                "json": {
+                    "clientContext": {
+                        "workflowId": workflowId
+                    },
+                    "uploadMediaInput": {
+                        "mediaCategory": category,
+                        "rawBytes": rawBytes,
+                        "caption": caption
+                    }
+                }
+            })
+        });
+        return uploadResult.uploadMediaGenerationId;
+    }
     /**
      * Tries to get media from their unique id
      *

package/dist/index.d.ts

@@ -3,3 +3,5 @@ export { Whisk } from "./Whisk.js";
 export { Media } from "./Media.js";
 export { Project } from "./Project.js";
 export * from "./Types.js";
+export * from "./Constants.js";
+export { imageToBase64, imageFromUrl } from "./Utils.js";

package/dist/index.js

@@ -3,3 +3,5 @@ export { Whisk } from "./Whisk.js";
 export { Media } from "./Media.js";
 export { Project } from "./Project.js";
 export * from "./Types.js";
+export * from "./Constants.js";
+export { imageToBase64, imageFromUrl } from "./Utils.js";

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@rohitaryal/whisk-api",
-    "version": "3.2.0",
+    "version": "4.0.1",
     "type": "module",
     "main": "./dist/index.js",
     "types": "./dist/index.d.ts",