@rohitaryal/whisk-api 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Rohit Sharma
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,153 @@
+# whisk-api
+
+[![Test](https://github.com/rohitaryal/whisk-api/actions/workflows/test.yaml/badge.svg)](https://github.com/rohitaryal/whisk-api/actions/workflows/test.yaml)
+[![License](https://img.shields.io/npm/l/whisk-api.svg)](https://github.com/rohitaryal/whisk-api/blob/main/LICENSE)
+[![TypeScript](https://img.shields.io/badge/TypeScript-007ACC?logo=typescript&logoColor=white)](https://www.typescriptlang.org/)
+[![Node.js](https://img.shields.io/badge/Node.js-339933?logo=node.js&logoColor=white)](https://nodejs.org/)
+[![Bun.js](https://img.shields.io/badge/Bun.js-000000?logo=bun&logoColor=pink)](https://nodejs.org/)
+
+An unofficial TypeScript/JavaScript API wrapper for Google Labs' Whisk image generation platform.
+
+## Features
+
+- **Image Generation**: Create high-quality images from text prompts
+- **Image Refinement**: Enhance and modify existing generated images
+- **Project Management**: Organize generations into projects with full CRUD operations
+- **Media Management**: Access generation history and download images
+- **Multiple Models**: Support for various Imagen models with different capabilities
+- **Type Safety**: Full TypeScript support with comprehensive type definitions
+
+## Installation
+
+```bash
+bun i whisk-api
+# or
+npm i whisk-api
+```
+
+## Quick Start
+
+```typescript
+import Whisk from 'whisk-api';
+
+const whisk = new Whisk({
+  cookie: "your_google_labs_cookie_here"
+});
+
+// Generate an image
+const result = await whisk.generateImage({
+  prompt: "A serene mountain landscape at sunset"
+});
+
+if (result.Ok) {
+  const imageData = result.Ok.imagePanels[0]?.generatedImages[0]?.encodedImage;
+  whisk.saveImage(imageData, "mountain_sunset.png");
+}
+```
+
+## Authentication
+
+You'll need to obtain your Google Labs session cookie:
+
+1. Visit [labs.google/fx/tools/whisk](https://labs.google/fx/tools/whisk)
+2. Open browser developer tools (F12)
+3. Go to Application/Storage → Cookies
+4. Copy the cookie value and use it in your configuration
+
+## Supported Models
+
+| Model | Description | Capabilities |
+|-------|-------------|--------------|
+| **Imagen 2** | Second generation model | Standard quality image generation |
+| **Imagen 3** | Third generation model | Improved quality and prompt adherence |
+| **Imagen 3.1** | Enhanced version of Imagen 3 | Better detail rendering |
+| **Imagen 4** | Latest generation model | Highest quality, best prompt understanding |
+| **Imagen 3 Portrait** | Portrait-optimized variant | Specialized for portrait generation |
+| **Imagen 3 Landscape** | Landscape-optimized variant | Specialized for landscape generation |
+| **Imagen 3 Portrait 3:4** | Portrait with 3:4 aspect ratio | Fixed aspect ratio portraits |
+| **Imagen 3 Landscape 4:3** | Landscape with 4:3 aspect ratio | Fixed aspect ratio landscapes |
+
+## Examples
+
+The library includes comprehensive examples in the [`examples/`](examples/) directory:
+
+- [Getting authorization tokens](examples/1_get_auth_tokens.ts)
+- [Checking credit status](examples/2_get_credit_status.ts)
+- [Creating projects](examples/3_create_new_project.ts)
+- [Managing project history](examples/4_list_all_project_history.ts)
+- [Project content management](examples/5_get_content_of_projects.ts)
+- [Deleting projects](examples/6_delete_projects.ts)
+- [Renaming projects](examples/7_rename_project.ts)
+- [Image generation history](examples/8_get_image_generation_history.ts)
+- [Saving images](examples/9_save_images.ts)
+- [Basic image generation](examples/10_generate_image.ts)
+- [Image refinement](examples/11_refine_image.ts)
+
+## API Reference
+
+### Core Methods
+
+- `generateImage(prompt)` - Generate images from text prompts
+- `refineImage(refinementRequest)` - Refine existing images with new prompts
+- `getProjectHistory(limit)` - Retrieve project history
+- `getImageHistory(limit)` - Retrieve image generation history
+- `getNewProjectId(title)` - Create new projects
+- `deleteProjects(projectIds)` - Delete multiple projects
+- `renameProject(newName, projectId)` - Rename existing projects
+- `saveImage(base64Data, fileName)` - Save images to disk
+- `getAuthorizationToken()` - Generate authentication tokens
+
+### Response Format
+
+All methods return a `Result<T>` type with either:
+- `Ok`: Contains the successful response data
+- `Err`: Contains error information
+
+```typescript
+const result = await whisk.generateImage({ prompt: "example" });
+if (result.Err) {
+  console.error("Generation failed:", result.Err);
+} else {
+  console.log("Success:", result.Ok);
+}
+```
+
+## Development
+
+```bash
+# Install dependencies
+bun install
+
+# Run tests
+bun test
+
+# Set up environment
+export COOKIE="your_cookie_here"
+```
+
+## Testing
+
+The test suite requires a valid Google Labs cookie. Set the `COOKIE` environment variable and run:
+
+```bash
+bun test
+```
+
+## Limitations
+
+- Requires valid Google Labs authentication
+- Rate limiting applies based on Google's policies
+- Regional availability may vary
+- Unofficial API subject to changes
+
+## Contributing
+
+Contributions are welcome. Please ensure all tests pass and follow the existing code style.
+
+## License
+
+This project is for educational and research purposes. Please respect Google's terms of service when using this library.
+
+## Disclaimer
+
+This is an unofficial API wrapper and is not affiliated with Google. Use at your own risk and ensure compliance with Google's terms of service.

package/bun.lock

@@ -0,0 +1,25 @@
+{
+  "lockfileVersion": 1,
+  "workspaces": {
+    "": {
+      "name": "whisk-api",
+      "devDependencies": {
+        "@types/bun": "latest",
+      },
+      "peerDependencies": {
+        "typescript": "^5",
+      },
+    },
+  },
+  "packages": {
+    "@types/bun": ["@types/bun@1.2.14", "", { "dependencies": { "bun-types": "1.2.14" } }, "sha512-VsFZKs8oKHzI7zwvECiAJ5oSorWndIWEVhfbYqZd4HI/45kzW7PN2Rr5biAzvGvRuNmYLSANY+H59ubHq8xw7Q=="],
+
+    "@types/node": ["@types/node@22.15.21", "", { "dependencies": { "undici-types": "~6.21.0" } }, "sha512-EV/37Td6c+MgKAbkcLG6vqZ2zEYHD7bvSrzqqs2RIhbA6w3x+Dqz8MZM3sP6kGTeLrdoOgKZe+Xja7tUB2DNkQ=="],
+
+    "bun-types": ["bun-types@1.2.14", "", { "dependencies": { "@types/node": "*" } }, "sha512-Kuh4Ub28ucMRWeiUUWMHsT9Wcbr4H3kLIO72RZZElSDxSu7vpetRvxIUDUaW6QtaIeixIpm7OXtNnZPf82EzwA=="],
+
+    "typescript": ["typescript@5.8.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-p1diW6TqL9L07nNxvRMM7hMMw4c5XOo/1ibL4aAIGmSAt9slTE1Xgw5KWuof2uTOvCg9BY7ZRi+GaF+7sfgPeQ=="],
+
+    "undici-types": ["undici-types@6.21.0", "", {}, "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ=="],
+  }
+}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@rohitaryal/whisk-api",
+  "module": "index.ts",
+  "type": "module",
+  "private": false,
+  "devDependencies": {
+    "@types/bun": "latest"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "scripts": {
+    "test": "bun test"
+  },
+  "main": "src/index.ts",
+  "description": "[![Test](https://github.com/rohitaryal/whisk-api/actions/workflows/test.yaml/badge.svg)](https://github.com/rohitaryal/whisk-api/actions/workflows/test.yaml) [![License](https://img.shields.io/npm/l/whisk-api.svg)](https://github.com/rohitaryal/whisk-api/blob/main/LICENSE) [![TypeScript](https://img.shields.io/badge/TypeScript-007ACC?logo=typescript&logoColor=white)](https://www.typescriptlang.org/) [![Node.js](https://img.shields.io/badge/Node.js-339933?logo=node.js&logoColor=white)](https://nodejs.org/) [![Bun.js](https://img.shields.io/badge/Bun.js-000000?logo=bun&logoColor=pink)](https://nodejs.org/)",
+  "version": "1.0.0",
+  "directories": {
+    "example": "examples",
+    "test": "tests"
+  },
+  "dependencies": {
+    "bun-types": "^1.2.14",
+    "typescript": "^5.8.3",
+    "undici-types": "^6.21.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rohitaryal/whisk-api.git"
+  },
+  "keywords": [
+    "whisk"
+  ],
+  "author": "rohitaryal",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/rohitaryal/whisk-api/issues"
+  },
+  "homepage": "https://github.com/rohitaryal/whisk-api#readme"
+}

package/src/global.types.ts

@@ -0,0 +1,172 @@
+export type ImageModel =
+  | "IMAGEN_2"
+  | "IMAGEN_3"
+  | "IMAGEN_3_1"
+  | "IMAGEN_3_5"
+  | "IMAGEN_3_PORTRAIT"
+  | "IMAGEN_3_LANDSCAPE"
+  | "IMAGEN_3_PORTRAIT_THREE_FOUR"
+  | "IMAGEN_3_LANDSCAPE_FOUR_THREE";
+export type AspectRatio =
+  | "IMAGE_ASPECT_RATIO_SQUARE"
+  | "IMAGE_ASPECT_RATIO_PORTRAIT"
+  | "IMAGE_ASPECT_RATIO_LANDSCAPE"
+  | "IMAGE_ASPECT_RATIO_UNSPECIFIED"
+  | "IMAGE_ASPECT_RATIO_LANDSCAPE_FOUR_THREE"
+  | "IMAGE_ASPECT_RATIO_PORTRAIT_THREE_FOUR";
+
+export interface Credentials {
+  cookie: string;
+  authorizationKey?: string;
+}
+
+export interface Result<T> {
+  Ok?: T;
+  Err?: Error;
+}
+
+export interface Request {
+  url: string;
+  headers: Headers;
+  body?: string;
+  method:
+  | "GET"
+  | "POST"
+  | "HEAD"
+  | "OPTIONS"
+  | "PUT"
+  | "PATCH"
+  | "DELETE";
+}
+
+export interface Prompt {
+  seed?: number;
+  prompt: string;
+  projectId?: string;
+  imageModel?: ImageModel;
+  aspectRatio?: AspectRatio;
+}
+
+export interface Projects {
+  name: string;
+  media: Media;
+  displayName: string;
+  createTime: string;
+}
+
+export interface Media {
+  name: string;
+  image: Image;
+  mediaGenerationId: MediaGenerationId;
+}
+
+export interface Image {
+  seed: number;
+  prompt: string;
+  modelNameType: string;
+  previousMediaGenerationId: string;
+  workflowId: string;
+  fingerprintLogRecordId: string;
+}
+
+export interface MediaGenerationId {
+  mediaType: string;
+  workflowId: string;
+  workflowStepId: string;
+  mediaKey: string;
+}
+
+export interface Images {
+  name: string;
+  media: Media;
+  createTime: string;
+}
+
+export interface FetchedImage {
+  name: string;
+  image: FetchedImageDetails;
+  createTime: string;
+  backboneMetadata: BackboneMetadata;
+  mediaGenerationId: MediaGenerationId;
+}
+
+export interface FetchedImageDetails {
+  encodedImage: string;
+  seed: number;
+  mediaGenerationId: string;
+  mediaVisibility: "PRIVATE" | "PUBLIC";
+  prompt: string;
+  modelNameType: string;
+  previousMediaGenerationId: string;
+  workflowId: string;
+  fingerprintLogRecordId: string;
+}
+
+export interface BackboneMetadata {
+  mediaCategory: "MEDIA_CATEGORY_BOARD";
+  recipeInput: RecipeInput;
+}
+
+export interface RecipeInput {
+  userInput: UserInput;
+  mediaInputs: MediaInput[];
+}
+
+export interface UserInput {
+  userInstructions: string;
+}
+
+export interface MediaInput {
+  mediaCategory: "MEDIA_CATEGORY_BOARD";
+}
+
+export interface ImageMetadata {
+  name: string;
+  image: ImageDetails;
+  createTime: string;
+  backboneMetadata: BackboneMetadata;
+}
+
+export interface ImageDetails {
+  mediaGenerationId: string;
+  mediaVisibility: "PRIVATE" | "PUBLIC";
+  prompt: string;
+}
+
+export interface GenerationResult {
+  imagePanels: ImagePanel[];
+  workflowId: string;
+}
+
+export interface ImagePanel {
+  prompt: string;
+  generatedImages: GeneratedImage[];
+}
+
+export interface GeneratedImage {
+  encodedImage: string;
+  seed: number;
+  mediaGenerationId: string;
+  prompt: string;
+  isMaskEditedImage?: boolean
+  modelNameType?: string;
+  workflowId?: string;
+  fingerprintLogRecordId?: string;
+  imageModel?: ImageModel;
+}
+
+export interface RefinementRequest {
+  existingPrompt: string;
+  newRefinement: string;
+  base64image: string;
+  /**
+   * The media key of the image you want to refine.
+   * You can get this by calling `getImageHistory()[0...N].name`
+   */
+  imageId: string;
+  seed?: number;
+  count?: number,
+  imageModel?: ImageModel;
+  aspectRatio?: AspectRatio;
+  projectId?: string;
+}

package/src/index.ts

@@ -0,0 +1,715 @@
+import type { Credentials, FetchedImage, GenerationResult, ImageMetadata, Images, Projects, Prompt, RefinementRequest, Result } from "./global.types";
+import type { Request } from "./global.types";
+import { request } from "./utils/request";
+import { writeFileSync } from "fs";
+
+export default class Whisk {
+  credentials: Credentials;
+
+  constructor(credentials: Credentials) {
+    if (!credentials.cookie || credentials.cookie == "INVALID_COOKIE") {
+      throw new Error("Cookie is missing or invalid.")
+    }
+
+    this.credentials = structuredClone(credentials)
+  }
+
+  async #checkCredentials() {
+    if (!this.credentials.cookie) {
+      throw new Error("Credentials are not set. Please provide a valid cookie.");
+    }
+
+    if (!this.credentials.authorizationKey) {
+      const resp = await this.getAuthorizationToken();
+
+      if (resp.Err || !resp.Ok) {
+        throw new Error("Failed to get authorization token: " + resp.Err);
+      }
+
+      this.credentials.authorizationKey = resp.Ok;
+    }
+  }
+
+  /**
+   * Check if `Whisk` is available in your region.
+   *
+   * This un-availability can be easily bypassed by
+   * generating authorization token from a region where
+   * its available. Use VPN with US regions.
+   */
+  async isAvailable(): Promise<Result<boolean>> {
+    const req: Request = {
+      body: "{}",
+      method: "POST",
+      url: "https://aisandbox-pa.googleapis.com/v1:checkAppAvailability",
+      headers: new Headers({ // The API key might not work next-time (unsure)
+        "Content-Type": "text/plain;charset=UTF-8",
+        "X-Goog-Api-Key": "AIzaSyBtrm0o5ab1c-Ec8ZuLcGt3oJAA5VWt3pY",
+      }),
+    };
+
+    const response = await request(req);
+    if (response.Err || !response.Ok) {
+      return { Err: response.Err };
+    }
+
+    try {
+      const responseBody = JSON.parse(response.Ok);
+      return { Ok: responseBody.availabilityState === "AVAILABLE" };
+    } catch (err) {
+      return { Err: new Error("Failed to parse response: " + response.Ok) };
+    }
+  }
+
+  /**
+   * Generates the authorization token for the user.
+   * This generated token is required to make *most* of API calls.
+   */
+  async getAuthorizationToken(): Promise<Result<string>> {
+    // Not on this one
+    // await this.#checkCredentials();
+    if (!this.credentials.cookie) {
+      return { Err: new Error("Empty or invalid cookies.") }
+    }
+
+    const req: Request = {
+      method: "GET",
+      url: "https://labs.google/fx/api/auth/session",
+      headers: new Headers({ "Cookie": String(this.credentials.cookie) }),
+    };
+
+    const resp = await request(req);
+    if (resp.Err || !resp.Ok) {
+      return { Err: resp.Err }
+    }
+
+    try {
+      const parsedResp = JSON.parse(resp.Ok);
+      const token = parsedResp?.access_token;
+
+      if (!token) {
+        return { Err: new Error("Failed to get session token: " + resp.Ok) }
+      }
+
+      // Let's not mutate the credentials directly
+      // this.credentials.authorizationKey = token;
+      return { Ok: String(token) };
+    } catch (err) {
+      return { Err: new Error("Failed to parse response: " + resp.Ok) };
+    }
+  }
+
+  /**
+   * Get the current credit status of the user. This is for `veo` only and not `whisk`.
+   */
+  async getCreditStatus(): Promise<Result<number>> {
+    await this.#checkCredentials();
+
+    const req: Request = {
+      method: "POST",
+      body: JSON.stringify({ "tool": "BACKBONE", "videoModel": "VEO_2_1_I2V" }), // Unknown of other models
+      url: "https://aisandbox-pa.googleapis.com/v1:GetUserVideoCreditStatusAction",
+      headers: new Headers({ "Authorization": String(this.credentials.authorizationKey) }),
+    };
+
+    const response = await request(req);
+    if (response.Err || !response.Ok) {
+      return { Err: response.Err };
+    }
+
+    try {
+      const responseBody = JSON.parse(response.Ok);
+
+      // Other properties don't seem to be useful
+      return { Ok: Number(responseBody.credits) }
+    } catch (err) {
+      return { Err: new Error("Failed to parse response: " + response.Ok) };
+    }
+  }
+
+  /**
+   * Generates a new project ID (a unique identifier for each project) for the
+   * given title so that you can start generating images in that specific project.
+   * 
+   * @param projectTitle The name you want to give to the project.
+   */
+  async getNewProjectId(projectTitle: string): Promise<Result<string>> {
+    await this.#checkCredentials();
+
+    const req: Request = {
+      method: "POST",
+      // Long ass JSON
+      body: JSON.stringify({
+        "json": {
+          "clientContext": {
+            "tool": "BACKBONE",
+            "sessionId": ";1748266079775" // Doesn't matter whatever the value is
+            // But probably the last login time
+          },
+          "workflowMetadata": { "workflowName": projectTitle }
+        }
+      }),
+      url: "https://labs.google/fx/api/trpc/media.createOrUpdateWorkflow",
+      headers: new Headers({ "Cookie": String(this.credentials.cookie) }),
+    };
+
+    const resp = await request(req);
+    if (resp.Err || !resp.Ok) {
+      return { Err: resp.Err }
+    }
+
+    try {
+      const parsedResp = JSON.parse(resp.Ok);
+      const workflowID = parsedResp?.result?.data?.json?.result?.workflowId;
+
+      return workflowID ? { Ok: String(workflowID) } : { Err: new Error("Failed to create new library" + resp.Ok) };
+    } catch (err) {
+      return { Err: new Error("Failed to parse response: " + resp.Ok) }
+    }
+  }
+
+  /**
+   * Get all of your project history or library.
+   * 
+   * @param limitCount The number of projects you want to fetch.
+   */
+  async getProjectHistory(limitCount: number): Promise<Result<Projects[]>> {
+    await this.#checkCredentials();
+
+    const reqJson = {
+      "json": {
+        "rawQuery": "",
+        "type": "BACKBONE",
+        "subtype": "PROJECT",
+        "limit": limitCount,
+        "cursor": null
+      },
+      "meta": { "values": { "cursor": ["undefined"] } }
+    };
+
+    const req: Request = {
+      method: "GET",
+      headers: new Headers({
+        "Content-Type": "application/json",
+        "Cookie": String(this.credentials.cookie),
+      }),
+      url: `https://labs.google/fx/api/trpc/media.fetchUserHistory?input=` + JSON.stringify(reqJson),
+    };
+
+    const resp = await request(req);
+    if (resp.Err || !resp.Ok) {
+      return { Err: resp.Err }
+    }
+
+    try {
+      const parsedResp = JSON.parse(resp.Ok);
+      const workflowList = parsedResp?.result?.data?.json?.result?.userWorkflows;
+
+      // More cases required here
+      if (workflowList && Array.isArray(workflowList)) {
+        return { Ok: workflowList as Projects[] }
+      }
+
+      return { Err: new Error("Failed to get project history: " + resp.Ok) }
+    } catch (err) {
+      return { Err: new Error("Failed to parse response: " + resp.Ok) };
+    }
+  }
+
+  /**
+   * Get the image history of the user.
+   * 
+   * @param limitCount The number of images you want to fetch.
+   */
+  async getImageHistory(limitCount: number): Promise<Result<Images[]>> {
+    await this.#checkCredentials();
+
+    // No upper known limit
+    if (limitCount <= 0) {
+      return { Err: new Error("Limit count must be between 1 and 100.") };
+    }
+
+    const reqJson = {
+      "json": {
+        "rawQuery": "",
+        "type": "BACKBONE",
+        "subtype": "IMAGE",
+        "limit": limitCount,
+        "cursor": null
+      },
+      "meta": { "values": { "cursor": ["undefined"] } }
+    };
+
+    const req: Request = {
+      method: "GET",
+      headers: new Headers({
+        "Content-Type": "application/json",
+        "Cookie": String(this.credentials.cookie),
+      }),
+      url: `https://labs.google/fx/api/trpc/media.fetchUserHistory?input=` + JSON.stringify(reqJson),
+    };
+
+    const resp = await request(req);
+    if (resp.Err || !resp.Ok) return { Err: resp.Err }
+
+    try {
+      const parsedResp = JSON.parse(resp.Ok);
+      const mediaList = parsedResp?.result?.data?.json?.result?.userWorkflows;
+
+      // More cases required here
+      if (mediaList && Array.isArray(mediaList)) {
+        return { Ok: mediaList as Images[] }
+      }
+
+      return { Err: new Error("Failed to get image history: " + resp.Ok) }
+    } catch (err) {
+      return { Err: new Error("Failed to parse response: " + resp.Ok) };
+    }
+  }
+
+  /**
+   * Fetches the content of a project by its ID.
+   * 
+   * @param projectId The ID of the project you want to fetch content from.
+   */
+  async getProjectContent(projectId: string): Promise<Result<ImageMetadata[]>> {
+    await this.#checkCredentials();
+
+    if (!projectId) {
+      return { Err: new Error("Project ID is required to fetch project content.") };
+    }
+
+    const reqJson = { "json": { "workflowId": projectId } };
+    const req: Request = {
+      method: "GET",
+      headers: new Headers({
+        "Content-Type": "application/json",
+        "Cookie": String(this.credentials.cookie),
+      }),
+      url: `https://labs.google/fx/api/trpc/media.getProjectWorkflow?input=` + JSON.stringify(reqJson),
+    };
+
+    const resp = await request(req);
+    if (resp.Err || !resp.Ok) {
+      return { Err: resp.Err }
+    }
+
+    try {
+      const parsedResp = JSON.parse(resp.Ok);
+      const mediaList = parsedResp?.result?.data?.json?.result?.media;
+
+      // More cases required here
+      if (!mediaList || !Array.isArray(mediaList)) {
+        return { Err: new Error("Failed to get project content: " + resp.Ok) };
+      }
+
+      return { Ok: mediaList as ImageMetadata[] };
+    } catch (err) {
+      return { Err: new Error("Failed to parse response: " + resp.Ok) };
+    }
+  }
+
+
+  /**
+   * Rename a project title.
+   * 
+   * @param newName New name for your project
+   * @param projectId Identifier for project that you need to rename
+   */
+  async renameProject(newName: string, projectId: string): Promise<Result<string>> {
+    if (!this.credentials.cookie) {
+      return { Err: new Error("Cookie field is empty") };
+    }
+
+    const reqJson = {
+      "json": {
+        "workflowId": projectId,
+        "clientContext": {
+          "sessionId": ";1748333296243",
+          "tool": "BACKBONE",
+          "workflowId": projectId
+        },
+        "workflowMetadata": { "workflowName": newName }
+      }
+    };
+
+    const req: Request = {
+      method: "POST",
+      body: JSON.stringify(reqJson),
+      headers: new Headers({
+        "Content-Type": "application/json",
+        "Cookie": String(this.credentials.cookie),
+      }),
+      url: "https://labs.google/fx/api/trpc/media.createOrUpdateWorkflow",
+    };
+
+    const resp = await request(req);
+    if (resp.Err || !resp.Ok) {
+      return { Err: resp.Err };
+    }
+
+    try {
+      const parsedBody = JSON.parse(resp.Ok);
+      const workflowId = parsedBody?.result?.data?.json?.result?.workflowId;
+
+      if (parsedBody.error || !workflowId) {
+        return { Err: new Error("Failed to rename project: " + resp.Ok) }
+      }
+
+      return { Ok: String(workflowId) }
+    } catch (err) {
+      return { Err: new Error("Failed to parse JSON: " + resp.Ok) }
+    }
+  }
+
+  /**
+   * Delete project(s) from libary
+   * 
+   * @param projectIds Array of project id that you need to delete.
+  */
+  async deleteProjects(projectIds: string[]): Promise<Result<boolean>> {
+    if (!this.credentials.cookie) {
+      return { Err: new Error("Cookie field is empty") };
+    }
+
+    const reqJson = {
+      "json":
+      {
+        "parent": "userProject/",
+        "names": projectIds,
+      }
+    };
+
+    const req: Request = {
+      method: "POST",
+      body: JSON.stringify(reqJson),
+      url: "https://labs.google/fx/api/trpc/media.deleteMedia",
+      headers: new Headers({
+        "Content-Type": "application/json",
+        "Cookie": String(this.credentials.cookie),
+      }
+      )
+    };
+
+    const resp = await request(req);
+    if (resp.Err || !resp.Ok) {
+      return { Err: resp.Err }
+    }
+
+    try {
+      const parsedResp = JSON.parse(resp.Ok);
+
+      if (parsedResp.error) {
+        return { Err: new Error("Failed to delete media: " + resp.Ok) }
+      }
+
+      return { Ok: true };
+    } catch (err) {
+      return { Err: new Error("Failed to parse JSON: " + resp.Ok) }
+    }
+  }
+
+  /**
+   * Fetches the base64 encoded image from its media key (name).
+   * Media key can be obtained by calling: `getImageHistory()[0...N].name`
+   * 
+   * @param mediaKey The media key of the image you want to fetch.
+   */
+  async getMedia(mediaKey: string): Promise<Result<FetchedImage>> {
+    await this.#checkCredentials();
+
+    if (!mediaKey) {
+      return { Err: new Error("Media key is required to fetch the image.") };
+    }
+
+    const reqJson = { "json": { "mediaKey": mediaKey } };
+    const req: Request = {
+      method: "GET",
+      headers: new Headers({
+        "Content-Type": "application/json",
+        "Cookie": String(this.credentials.cookie),
+      }),
+      url: `https://labs.google/fx/api/trpc/media.fetchMedia?input=` + JSON.stringify(reqJson),
+    };
+
+    const resp = await request(req);
+    if (resp.Err || !resp.Ok) {
+      return { Err: resp.Err }
+    }
+
+    try {
+      const parsedResp = JSON.parse(resp.Ok);
+      const image = parsedResp?.result?.data?.json?.result;
+
+      if (!image) {
+        return { Err: new Error("Failed to get media: " + resp.Ok) };
+      }
+
+      return { Ok: image as FetchedImage };
+    } catch (err) {
+      return { Err: new Error("Failed to parse response: " + resp.Ok) };
+    }
+  }
+
+  /**
+   * Generates an image based on the provided prompt.
+   * 
+   * @param prompt The prompt containing the details for image generation.
+   */
+  async generateImage(prompt: Prompt): Promise<Result<GenerationResult>> {
+    await this.#checkCredentials();
+
+    if (!prompt || !prompt.prompt) {
+      return { Err: new Error("Invalid prompt. Please provide a valid prompt and projectId") };
+    }
+
+    // You missed the projectId, so let's create a new one
+    if (!prompt.projectId) {
+      const id = await this.getNewProjectId("New Project");
+      if (id.Err || !id.Ok)
+        return { Err: id.Err }
+
+      prompt.projectId = id.Ok;
+    }
+
+    // Because seed can be zero
+    if (prompt.seed == undefined) {
+      prompt.seed = 0;
+    }
+
+    if (!prompt.imageModel) {
+      prompt.imageModel = "IMAGEN_3_5";
+    }
+
+    if (!prompt.aspectRatio) {
+      prompt.aspectRatio = "IMAGE_ASPECT_RATIO_LANDSCAPE"; // Default in frontend
+    }
+
+    const reqJson = {
+      "clientContext": {
+        "workflowId": prompt.projectId,
+        "tool": "BACKBONE",
+        "sessionId": ";1748281496093"
+      },
+      "imageModelSettings": {
+        "imageModel": prompt.imageModel,
+        "aspectRatio": prompt.aspectRatio,
+      },
+      "seed": prompt.seed,
+      "prompt": prompt.prompt,
+      "mediaCategory": "MEDIA_CATEGORY_BOARD"
+    };
+
+    const req: Request = {
+      method: "POST",
+      body: JSON.stringify(reqJson),
+      url: "https://aisandbox-pa.googleapis.com/v1/whisk:generateImage",
+      headers: new Headers({
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${String(this.credentials.authorizationKey)}`, // Requires bearer
+      }),
+    };
+
+    const resp = await request(req);
+    if (resp.Err || !resp.Ok) {
+      return { Err: resp.Err }
+    }
+
+    try {
+      const parsedResp = JSON.parse(resp.Ok);
+      if (parsedResp.error) {
+        return { Err: new Error("Failed to generate image: " + resp.Ok) }
+      }
+
+      return { Ok: parsedResp as GenerationResult }
+    } catch (err) {
+      return { Err: new Error("Failed to parse response:" + resp.Ok) }
+    }
+  }
+
+  /**
+   * Refine a generated image.
+   * 
+   * Refination actually happens in the followin way:
+   * 1. Client provides an image (base64 encoded) to refine with new prompt eg: "xyz".
+   * 2. Server responds with *a new prompt describing your image* eg: AI-Mix("pqr", "xyz") 
+   *    Where `pqr` - Description of original image
+   * 3. Client requests image re-generation as: AI-Mix("pqr", "xyz")
+   * 4. Server responds with new base64 encoded image
+   */
+  async refineImage(ref: RefinementRequest): Promise<Result<GenerationResult>> {
+    await this.#checkCredentials();
+
+    if (ref.seed == undefined) {
+      ref.seed = 0;
+    }
+
+    if (!ref.aspectRatio) {
+      ref.aspectRatio = "IMAGE_ASPECT_RATIO_LANDSCAPE"; // Default in frontend
+    }
+
+    if (!ref.imageModel) {
+      ref.imageModel = "IMAGEN_3_5"; // Default in frontend (This is actually Imagen 4)
+    }
+
+    if (!ref.count) {
+      ref.count = 1; // Default in frontend
+    }
+
+    const reqJson = {
+      "json": {
+        "existingPrompt": ref.existingPrompt,
+        "textInput": ref.newRefinement,
+        "editingImage": {
+          "imageId": ref.imageId,
+          "base64Image": ref.base64image,
+          "category": "STORYBOARD",
+          "prompt": ref.existingPrompt,
+          "mediaKey": ref.imageId,
+          "isLoading": false,
+          "isFavorite": null,
+          "isActive": true,
+          "isPreset": false,
+          "isSelected": false,
+          "index": 0,
+          "imageObjectUrl": "blob:https://labs.google/1c612ac4-ecdf-4f77-9898-82ac488ad77f",
+          "recipeInput": {
+            "mediaInputs": [],
+            "userInput": {
+              "userInstructions": ref.existingPrompt
+            }
+          },
+          "currentImageAction": "REFINING",
+          "seed": ref.seed
+        },
+        "sessionId": ";1748338835952" // doesn't matter
+      },
+      "meta": {
+        "values": {
+          "editingImage.isFavorite": [
+            "undefined"
+          ]
+        }
+      }
+    };
+
+    const req: Request = {
+      method: "POST",
+      body: JSON.stringify(reqJson),
+      url: "https://labs.google/fx/api/trpc/backbone.generateRewrittenPrompt",
+      headers: new Headers({
+        "Content-Type": "application/json",
+        "Cookie": String(this.credentials.cookie),
+      }),
+    };
+
+    const resp = await request(req);
+    if (resp.Err || !resp.Ok) {
+      return { Err: resp.Err }
+    }
+
+    let parsedResp;
+    try {
+      parsedResp = JSON.parse(resp.Ok);
+      if (parsedResp.error) {
+        return { Err: new Error("Failed to refine image: " + resp.Ok) };
+      }
+    }
+    catch (err) {
+      return { Err: new Error("Failed to parse response: " + resp.Ok) };
+    }
+
+    const newPrompt = parsedResp?.result?.data?.json;
+    if (!newPrompt) {
+      return { Err: new Error("Failed to get new prompt from response: " + resp.Ok) };
+    }
+
+    const reqJson2 = {
+      "userInput": {
+        "candidatesCount": ref.count,
+        "seed": ref.seed,
+        "prompts": [newPrompt],
+        "mediaCategory": "MEDIA_CATEGORY_BOARD",
+        "recipeInput": {
+          "userInput": {
+            "userInstructions": newPrompt,
+          },
+          "mediaInputs": []
+        }
+      },
+      "clientContext": {
+        "sessionId": ";1748338835952", // can be anything
+        "tool": "BACKBONE",
+        "workflowId": ref.projectId,
+      },
+      "modelInput": {
+        "modelNameType": ref.imageModel
+      },
+      "aspectRatio": ref.aspectRatio
+    }
+
+    const req2: Request = {
+      method: "POST",
+      body: JSON.stringify(reqJson2),
+      url: "https://aisandbox-pa.googleapis.com/v1:runBackboneImageGeneration",
+      headers: new Headers({
+        "Content-Type": "text/plain;charset=UTF-8", // Yes
+        "Authorization": `Bearer ${String(this.credentials.authorizationKey)}`, // Requires bearer
+      }),
+    };
+
+    const resp2 = await request(req2);
+    if (resp2.Err || !resp2.Ok) {
+      return { Err: resp2.Err }
+    }
+
+    try {
+      const parsedResp2 = JSON.parse(resp2.Ok);
+      if (parsedResp2.error) {
+        return { Err: new Error("Failed to refine image: " + resp2.Ok) };
+      }
+
+      return { Ok: parsedResp2 as GenerationResult };
+    } catch (err) {
+      return { Err: new Error("Failed to parse response: " + resp2.Ok) };
+    }
+  }
+
+  /**
+   * Save image to a file with the given name.
+   * 
+   * @param image The base64 encoded image string.
+   * @param fileName The name of the file where the image will be saved.
+   */
+  saveImage(image: string, fileName: string): Error | null {
+    try {
+      writeFileSync(fileName, image, { encoding: 'base64' });
+      return null;
+    } catch (err) {
+      return new Error("Failed to save image: " + err);
+    }
+  }
+
+  /**
+   * Save image from its id directly
+   * 
+   * @param imageId The ID of the image you want to save.
+   * @param fileName The name of the file where the image will be saved.
+   */
+  async saveImageDirect(imageId: string, fileName: string): Promise<Result<boolean>> {
+    const image = await this.getMedia(imageId);
+
+    if (image.Err || !image.Ok) {
+      return { Err: image.Err };
+    }
+
+    try {
+      writeFileSync(fileName, image.Ok.image.encodedImage, { encoding: 'base64' });
+      return { Ok: true };
+    } catch (err) {
+      return {
+        Err: new Error("Failed to save image: " + err)
+      }
+    }
+  }
+}

package/src/utils/request.ts

@@ -0,0 +1,39 @@
+import type { Request, Result } from "../global.types";
+
+const request = async function (req: Request): Promise<Result<string>> {
+  req.headers.set("Origin", "https://labs.google");
+  req.headers.set("Referer", "https://labs.google/fx/tools/whisk");
+
+  // console.log(req.headers);
+
+  // if (!req.headers.has("Authorization")) {
+  //   console.warn("Warning: Request is missing authorization headers: " + req.url)
+  // }
+
+  try {
+    const reqs = await fetch(req.url, {
+      body: req.body,
+      method: req.method,
+      headers: req.headers,
+    });
+
+    const res = await reqs.text();
+
+    if (!reqs.ok) {
+      return {
+        Err: new Error(res)
+      }
+    }
+
+    return {
+      Ok: res,
+    };
+
+  } catch (err) {
+    return {
+      Err: (err instanceof Error) ? err : new Error("Failed to fetch.")
+    }
+  }
+}
+
+export { request };