Fixed undo of stroke.

- Create 3d model from image works now (accessed via wand button next to
the + asset button).
- Modal pops up, or if you dont have a FAL api set in settings it'll pop
up an action reminder to set it first.
- You can choose image from library (opens gallery select mode) or
upload an image from computer.
- Pressing create enqueues the image to 3d and closes the modal.
Spinning loading toast on the top right says Generating... until it
finishes.
- When done, currently it just pops up in the library and you can drag
it onto the scene yourself.

**Current bugs/missing features:**
1. No 3D object image thumbnail in gallery
2. If you open up the gallery and try add the newly generated 3d object
to the scene, it will be stuck at "loading" text because of a CORS error
(not sure why). Pressing the button to refresh the gallery before
dragging it in seems to fix that though.

Cargo.lock

@@ -688,6 +688,7 @@ dependencies = [
  "tokio",
  "tokio-util",
  "url",
+ "web_base64",
  "workspace-build-acceleration",
 ]
 
@@ -3597,6 +3598,7 @@ dependencies = [
  "fal",
  "file_to_base64_url",
  "futures 0.3.31",
+ "log",
  "reqwest 0.12.15",
  "serde",
  "testing",
@@ -12210,6 +12212,14 @@ dependencies = [
  "wasm-bindgen",
 ]
 
+[[package]]
+name = "web_base64"
+version = "0.0.1"
+dependencies = [
+ "base64 0.22.1",
+ "workspace-build-acceleration",
+]
+
 [[package]]
 name = "web_scrapers"
 version = "0.0.1"

Cargo.toml

@@ -43,6 +43,7 @@ members = [
   "crates/lib/data/crockford",
   "crates/lib/data/datetimes",
   "crates/lib/data/primitives",
+  "crates/lib/data/web_base64",
   "crates/lib/deprecated/config", # TODO(bt, 2023-02-13): Deprecate or repurpose
   "crates/lib/deprecated/http_server_common", # TODO(bt, 2023-03-20): Move useful pieces to actix_helpers
   "crates/lib/dimensions",
@@ -228,3 +229,4 @@ shared_service_components = { path = "crates/lib/shared_service_components" }
 storyteller_client = { path = "crates/lib/api_clients/storyteller_client" }
 subprocess_common = { path = "crates/lib/subprocess_common" }
 tokens = { path = "crates/schema/public/tokens" }
+web_base64= { path = "crates/lib/data/web_base64" }

crates/desktop/artcraft/Cargo.toml

@@ -35,6 +35,7 @@ openai_sora_client = { workspace = true }
 primitives = { workspace = true }
 storyteller_client = { workspace = true }
 tokens = { workspace = true }
+web_base64 = { workspace = true }
 
 # External
 anyhow = { workspace = true }

crates/desktop/artcraft/src/core/artcraft_error.rs

@@ -0,0 +1,48 @@
+use std::error::Error;
+use std::fmt::{Display, Formatter};
+use storyteller_client::error::storyteller_error::StorytellerError;
+
+#[derive(Debug)]
+pub enum ArtcraftError {
+  AnyhowError(anyhow::Error),
+  DecodeError(base64::DecodeError),
+  IoError(std::io::Error),
+  StorytellerError(StorytellerError),
+}
+
+impl Error for ArtcraftError {}
+
+impl Display for ArtcraftError {
+  fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+    match self {
+      Self::AnyhowError(e) => write!(f, "AnyhowError: {:?}", e),
+      Self::DecodeError(e) => write!(f, "DecodeError: {:?}", e),
+      Self::IoError(e) => write!(f, "IoError: {:?}", e),
+      Self::StorytellerError(e) => write!(f, "StorytellerError: {:?}", e),
+    }
+  }
+}
+
+impl From<anyhow::Error> for ArtcraftError {
+  fn from(value: anyhow::Error) -> Self {
+    Self::AnyhowError(value)
+  }
+}
+
+impl From<base64::DecodeError> for ArtcraftError {
+  fn from(value: base64::DecodeError) -> Self {
+    Self::DecodeError(value)
+  }
+}
+
+impl From<std::io::Error> for ArtcraftError {
+  fn from(value: std::io::Error) -> Self {
+    Self::IoError(value)
+  }
+}
+
+impl From<StorytellerError> for ArtcraftError {
+  fn from(value: StorytellerError) -> Self {
+    Self::StorytellerError(value)
+  }
+}

crates/desktop/artcraft/src/core/commands/enqueue/image/enqueue_text_to_image_command.rs

@@ -1,5 +1,5 @@
-use crate::core::commands::enqueue::image::handle_fal::handle_fal;
-use crate::core::commands::enqueue::image::handle_sora::handle_sora;
+use crate::core::commands::enqueue::image::handle_image_fal::handle_image_fal;
+use crate::core::commands::enqueue::image::handle_image_sora::handle_image_sora;
 use crate::core::commands::enqueue::image::internal_image_error::InternalImageError;
 use crate::core::commands::response::failure_response_wrapper::{CommandErrorResponseWrapper, CommandErrorStatus};
 use crate::core::commands::response::shorthand::Response;
@@ -24,7 +24,7 @@ use base64::prelude::BASE64_STANDARD;
 use base64::{DecodeError, Engine};
 use errors::{AnyhowError, AnyhowResult};
 use fal_client::error::fal_error_plus::FalErrorPlus;
-use fal_client::requests::queue::image_gen::enqueue_flux_pro_ultra_text_to_image::{enqueue_flux_pro_ultra_text_to_image, FluxProUltraTextToImageArgs};
+use fal_client::requests::queue::image_gen::enqueue_flux_pro_11_ultra_text_to_image::{enqueue_flux_pro_11_ultra_text_to_image, FluxPro11UltraTextToImageArgs};
 use fal_client::requests::queue::image_gen::enqueue_recraft3_text_to_image::{enqueue_recraft3_text_to_image, Recraft3TextToImageArgs};
 use filesys::file_read_bytes::file_read_bytes;
 use image::codecs::png::{CompressionType, FilterType, PngEncoder};
@@ -55,6 +55,8 @@ use storyteller_client::media_files::upload_image_media_file_from_file::upload_i
 use storyteller_client::utils::api_host::ApiHost;
 use tauri::{AppHandle, Emitter, Manager, State};
 use tempfile::NamedTempFile;
+use crate::core::commands::enqueue::image::handle_image_artcraft::handle_image_artcraft;
+use crate::core::commands::enqueue::object::handle_object_artcraft::handle_object_artcraft;
 
 #[derive(Deserialize)]
 pub struct EnqueueTextToImageRequest {
@@ -93,6 +95,8 @@ pub enum EnqueueTextToImageErrorType {
   NeedsFalApiKey,
   /// Fal had an API error
   FalError,
+  /// Needs to be logged into Artcraft
+  NeedsStorytellerCredentials,
 }
 
 
@@ -172,13 +176,20 @@ pub async fn handle_request(
     None => {
       return Err(InternalImageError::NoModelSpecified);
     }
-    Some(EnqueueTextToImageModel::FluxProUltra) | Some(EnqueueTextToImageModel::Recraft3) => {
-      handle_fal(&app, request, fal_creds_manager, fal_task_queue).await?;
-    },
     Some(EnqueueTextToImageModel::GptImage1) => {
-      handle_sora(&app, request, sora_creds_manager, sora_task_queue).await?;
+      handle_image_sora(&app, request, sora_creds_manager, sora_task_queue).await?;
+      return Ok(());
+    }
+    _ => {
+      // Fall-through
     }
   };
 
+  if fal_creds_manager.has_apparent_api_token()? {
+    handle_image_fal(&app, request, fal_creds_manager, fal_task_queue).await?;
+  } else {
+    handle_image_artcraft(request, &app, app_data_root, storyteller_creds_manager).await?;
+  }
+
   Ok(())
 }

crates/desktop/artcraft/src/core/commands/enqueue/image/handle_image_artcraft.rs

@@ -0,0 +1,95 @@
+use crate::core::commands::enqueue::image::enqueue_text_to_image_command::{EnqueueTextToImageModel, EnqueueTextToImageRequest};
+use crate::core::commands::enqueue::image::internal_image_error::InternalImageError;
+use crate::core::events::basic_sendable_event_trait::BasicSendableEvent;
+use crate::core::events::generation_events::common::{GenerationAction, GenerationModel, GenerationServiceProvider};
+use crate::core::events::generation_events::generation_enqueue_failure_event::GenerationEnqueueFailureEvent;
+use crate::core::events::generation_events::generation_enqueue_success_event::GenerationEnqueueSuccessEvent;
+use crate::core::state::data_dir::app_data_root::AppDataRoot;
+use crate::core::utils::download_media_file_to_temp_dir::download_media_file_to_temp_dir;
+use crate::core::utils::save_base64_image_to_temp_dir::save_base64_image_to_temp_dir;
+use crate::services::fal::state::fal_credential_manager::FalCredentialManager;
+use crate::services::fal::state::fal_task_queue::FalTaskQueue;
+use crate::services::sora::state::sora_credential_manager::SoraCredentialManager;
+use crate::services::sora::state::sora_task_queue::SoraTaskQueue;
+use crate::services::storyteller::state::storyteller_credential_manager::StorytellerCredentialManager;
+use anyhow::anyhow;
+use artcraft_api_defs::generate::image::generate_flux_pro_11_ultra_text_to_image::GenerateFluxPro11UltraTextToImageRequest;
+use artcraft_api_defs::generate::object::generate_hunyuan_2_image_to_3d::GenerateHunyuan2ImageTo3dRequest;
+use artcraft_api_defs::generate::video::generate_kling_1_6_pro_image_to_video::GenerateKling16ProImageToVideoRequest;
+use fal_client::creds::fal_api_key::FalApiKey;
+use fal_client::requests::queue::enqueue_hunyuan2_image_to_3d::{enqueue_hunyuan2_image_to_3d, Hunyuan2Args};
+use fal_client::requests::queue::image_gen::enqueue_flux_pro_11_ultra_text_to_image::{enqueue_flux_pro_11_ultra_text_to_image, FluxPro11UltraTextToImageArgs};
+use fal_client::requests::queue::image_gen::enqueue_recraft3_text_to_image::{enqueue_recraft3_text_to_image, Recraft3TextToImageArgs};
+use idempotency::uuid::generate_random_uuid;
+use log::{error, info, warn};
+use storyteller_client::generate::image::generate_flux_pro_11_ultra_text_to_image::generate_flux_pro_11_ultra_text_to_image;
+use storyteller_client::generate::object::generate_hunyuan2_image_to_3d::generate_hunyuan2_image_to_3d;
+use storyteller_client::generate::video::generate_kling_16_pro_image_to_video::generate_kling_16_pro_image_to_video;
+use storyteller_client::utils::api_host::ApiHost;
+use tauri::{AppHandle, State};
+
+pub async fn handle_image_artcraft(
+  request: EnqueueTextToImageRequest,
+  app: &AppHandle,
+  app_data_root: &AppDataRoot,
+  storyteller_creds_manager: &StorytellerCredentialManager,
+) -> Result<(), InternalImageError> {
+
+  let creds = match storyteller_creds_manager.get_credentials()? {
+    Some(creds) => creds,
+    None => {
+      error!("No Artcraft credentials are set. Can't perform action.");
+      let event =
+          GenerationEnqueueFailureEvent::no_artcraft_credentials(GenerationAction::GenerateImage);
+
+      if let Err(err) = event.send(&app) {
+        error!("Failed to emit event: {:?}", err); // Fail open.
+      }
+      
+      return Err(InternalImageError::NeedsStorytellerCredentials);
+    },
+  };
+  
+  info!("Calling Artcraft text to image...");
+
+  let uuid_idempotency_token = generate_random_uuid();
+  
+  let mut selected_model = None;
+  
+  let job_token = match request.model {
+    None => {
+      return Err(InternalImageError::NoModelSpecified);
+    }
+    Some(EnqueueTextToImageModel::GptImage1) => {
+      return Err(InternalImageError::AnyhowError(anyhow!("wrong logic: artcraft is handling sora images")));
+    }
+    Some(EnqueueTextToImageModel::Recraft3) => {
+      return Err(InternalImageError::AnyhowError(anyhow!("not yet implemented in Artcraft")));
+    }
+    Some(EnqueueTextToImageModel::FluxProUltra) => {
+      info!("enqueue Flux Pro Ultra");
+      selected_model = Some(GenerationModel::FluxPro11Ultra);
+      let request = GenerateFluxPro11UltraTextToImageRequest {
+        uuid_idempotency_token,
+        prompt: request.prompt,
+      };
+      let result = generate_flux_pro_11_ultra_text_to_image(
+        &ApiHost::Storyteller,
+        Some(&creds),
+        request,
+      ).await;
+      match result {
+        Ok(enqueued) => {
+          info!("Successfully enqueued Artcraft flux pro ultra text to image generation");
+          enqueued.inference_job_token
+        }
+        Err(err) => {
+          error!("Failed to use Artcraft flux pro ultra text to image generation: {:?}", err);
+          return Err(InternalImageError::StorytellerError(err));
+        }
+      }
+    }
+  };
+
+  Ok(())
+}

crates/desktop/artcraft/src/core/commands/enqueue/image/handle_image_fal.rs

@@ -12,12 +12,12 @@ use crate::services::sora::state::sora_task_queue::SoraTaskQueue;
 use crate::services::storyteller::state::storyteller_credential_manager::StorytellerCredentialManager;
 use anyhow::anyhow;
 use fal_client::creds::fal_api_key::FalApiKey;
-use fal_client::requests::queue::image_gen::enqueue_flux_pro_ultra_text_to_image::{enqueue_flux_pro_ultra_text_to_image, FluxProUltraTextToImageArgs};
+use fal_client::requests::queue::image_gen::enqueue_flux_pro_11_ultra_text_to_image::{enqueue_flux_pro_11_ultra_text_to_image, FluxPro11UltraTextToImageArgs};
 use fal_client::requests::queue::image_gen::enqueue_recraft3_text_to_image::{enqueue_recraft3_text_to_image, Recraft3TextToImageArgs};
 use log::{error, info, warn};
 use tauri::AppHandle;
 
-pub async fn handle_fal(
+pub async fn handle_image_fal(
   app: &AppHandle,
   request: EnqueueTextToImageRequest,
   fal_creds_manager: &FalCredentialManager,
@@ -56,7 +56,7 @@ pub async fn handle_fal(
     }
     Some(EnqueueTextToImageModel::FluxProUltra) => {
       info!("enqueue Flux Pro Ultra text-to-image with prompt: {}", prompt);
-      enqueue_flux_pro_ultra_text_to_image(FluxProUltraTextToImageArgs {
+      enqueue_flux_pro_11_ultra_text_to_image(FluxPro11UltraTextToImageArgs {
         prompt,
         api_key: &api_key,
       }).await

crates/desktop/artcraft/src/core/commands/enqueue/image/handle_image_sora.rs

@@ -11,7 +11,7 @@ use crate::services::sora::state::sora_credential_manager::SoraCredentialManager
 use crate::services::sora::state::sora_task_queue::SoraTaskQueue;
 use crate::services::storyteller::state::storyteller_credential_manager::StorytellerCredentialManager;
 use anyhow::anyhow;
-use fal_client::requests::queue::image_gen::enqueue_flux_pro_ultra_text_to_image::{enqueue_flux_pro_ultra_text_to_image, FluxProUltraTextToImageArgs};
+use fal_client::requests::queue::image_gen::enqueue_flux_pro_11_ultra_text_to_image::{enqueue_flux_pro_11_ultra_text_to_image, FluxPro11UltraTextToImageArgs};
 use fal_client::requests::queue::image_gen::enqueue_recraft3_text_to_image::{enqueue_recraft3_text_to_image, Recraft3TextToImageArgs};
 use log::{error, info, warn};
 use openai_sora_client::creds::sora_credential_set::SoraCredentialSet;
@@ -25,7 +25,7 @@ use tauri::AppHandle;
 
 const SORA_SIMPLE_IMAGE_GEN_TIMEOUT : Duration = Duration::from_millis(1000 * 30); // 30 seconds
 
-pub async fn handle_sora(
+pub async fn handle_image_sora(
   app: &AppHandle,
   request: EnqueueTextToImageRequest,
   sora_creds_manager: &SoraCredentialManager,

crates/desktop/artcraft/src/core/commands/enqueue/image/internal_image_error.rs

@@ -1,20 +1,23 @@
+use crate::core::artcraft_error::ArtcraftError;
 use base64::DecodeError;
 use errors::AnyhowError;
 use fal_client::error::fal_error_plus::FalErrorPlus;
 use openai_sora_client::sora_error::SoraError;
-use storyteller_client::error::api_error::ApiError;
+use storyteller_client::error::storyteller_error::StorytellerError;
 
 #[derive(Debug)]
 pub enum InternalImageError {
   NoModelSpecified,
   NeedsFalApiKey,
   NeedsSoraCredentials,
+  NeedsStorytellerCredentials,
   FalError(FalErrorPlus),
   SoraError(SoraError),
   AnyhowError(AnyhowError),
-  StorytellerApiError(ApiError),
+  StorytellerError(StorytellerError),
   DecodeError(DecodeError),
   IoError(std::io::Error),
+  ArtcraftError(ArtcraftError),
 }
 
 impl From<AnyhowError> for InternalImageError {
@@ -35,9 +38,9 @@ impl From<SoraError> for InternalImageError {
   }
 }
 
-impl From<ApiError> for InternalImageError {
-  fn from(value: ApiError) -> Self {
-    Self::StorytellerApiError(value)
+impl From<StorytellerError> for InternalImageError {
+  fn from(value: StorytellerError) -> Self {
+    Self::StorytellerError(value)
   }
 }
 
@@ -52,3 +55,15 @@ impl From<std::io::Error> for InternalImageError {
     Self::IoError(value)
   }
 }
+
+impl From<ArtcraftError> for InternalImageError {
+  fn from(value: ArtcraftError) -> Self {
+    match value {
+      ArtcraftError::AnyhowError(e) => Self::AnyhowError(e),
+      ArtcraftError::DecodeError(e) => Self::DecodeError(e),
+      ArtcraftError::IoError(e) => Self::IoError(e),
+      ArtcraftError::StorytellerError(e) => Self::StorytellerError(e),
+      _ => Self::ArtcraftError(value),
+    }
+  }
+}

crates/desktop/artcraft/src/core/commands/enqueue/image/mod.rs

@@ -1,4 +1,5 @@
 pub mod enqueue_text_to_image_command;
-pub mod handle_fal;
-pub mod handle_sora;
+pub mod handle_image_artcraft;
+pub mod handle_image_fal;
+pub mod handle_image_sora;
 pub mod internal_image_error;

crates/desktop/artcraft/src/core/commands/enqueue/mod.rs

@@ -1,2 +1,3 @@
 pub mod image;
-pub mod object;
+pub mod object;
+pub mod video;

crates/desktop/artcraft/src/core/commands/enqueue/object/enqueue_image_to_3d_object_command.rs

@@ -1,5 +1,4 @@
-use crate::core::commands::enqueue::image::handle_fal::handle_fal;
-use crate::core::commands::enqueue::image::handle_sora::handle_sora;
+use crate::core::commands::enqueue::object::handle_object_artcraft::handle_object_artcraft;
 use crate::core::commands::enqueue::object::handle_object_fal::handle_object_fal;
 use crate::core::commands::enqueue::object::internal_object_error::InternalObjectError;
 use crate::core::commands::response::failure_response_wrapper::{CommandErrorResponseWrapper, CommandErrorStatus};
@@ -25,7 +24,7 @@ use base64::prelude::BASE64_STANDARD;
 use base64::{DecodeError, Engine};
 use errors::{AnyhowError, AnyhowResult};
 use fal_client::error::fal_error_plus::FalErrorPlus;
-use fal_client::requests::queue::image_gen::enqueue_flux_pro_ultra_text_to_image::{enqueue_flux_pro_ultra_text_to_image, FluxProUltraTextToImageArgs};
+use fal_client::requests::queue::image_gen::enqueue_flux_pro_11_ultra_text_to_image::{enqueue_flux_pro_11_ultra_text_to_image, FluxPro11UltraTextToImageArgs};
 use fal_client::requests::queue::image_gen::enqueue_recraft3_text_to_image::{enqueue_recraft3_text_to_image, Recraft3TextToImageArgs};
 use filesys::file_read_bytes::file_read_bytes;
 use image::codecs::png::{CompressionType, FilterType, PngEncoder};
@@ -57,7 +56,6 @@ use storyteller_client::utils::api_host::ApiHost;
 use tauri::{AppHandle, Emitter, Manager, State};
 use tempfile::NamedTempFile;
 use tokens::tokens::media_files::MediaFileToken;
-use crate::core::commands::enqueue::object::handle_object_artcraft::handle_object_artcraft;
 
 #[derive(Deserialize)]
 pub struct EnqueueImageTo3dObjectRequest {

crates/desktop/artcraft/src/core/commands/enqueue/object/handle_object_artcraft.rs

@@ -17,7 +17,7 @@ use anyhow::anyhow;
 use artcraft_api_defs::generate::object::generate_hunyuan_2_image_to_3d::GenerateHunyuan2ImageTo3dRequest;
 use fal_client::creds::fal_api_key::FalApiKey;
 use fal_client::requests::queue::enqueue_hunyuan2_image_to_3d::{enqueue_hunyuan2_image_to_3d, Hunyuan2Args};
-use fal_client::requests::queue::image_gen::enqueue_flux_pro_ultra_text_to_image::{enqueue_flux_pro_ultra_text_to_image, FluxProUltraTextToImageArgs};
+use fal_client::requests::queue::image_gen::enqueue_flux_pro_11_ultra_text_to_image::{enqueue_flux_pro_11_ultra_text_to_image, FluxPro11UltraTextToImageArgs};
 use fal_client::requests::queue::image_gen::enqueue_recraft3_text_to_image::{enqueue_recraft3_text_to_image, Recraft3TextToImageArgs};
 use idempotency::uuid::generate_random_uuid;
 use log::{error, info, warn};

crates/desktop/artcraft/src/core/commands/enqueue/object/handle_object_fal.rs

@@ -16,7 +16,7 @@ use crate::services::storyteller::state::storyteller_credential_manager::Storyte
 use anyhow::anyhow;
 use fal_client::creds::fal_api_key::FalApiKey;
 use fal_client::requests::queue::enqueue_hunyuan2_image_to_3d::{enqueue_hunyuan2_image_to_3d, Hunyuan2Args};
-use fal_client::requests::queue::image_gen::enqueue_flux_pro_ultra_text_to_image::{enqueue_flux_pro_ultra_text_to_image, FluxProUltraTextToImageArgs};
+use fal_client::requests::queue::image_gen::enqueue_flux_pro_11_ultra_text_to_image::{enqueue_flux_pro_11_ultra_text_to_image, FluxPro11UltraTextToImageArgs};
 use fal_client::requests::queue::image_gen::enqueue_recraft3_text_to_image::{enqueue_recraft3_text_to_image, Recraft3TextToImageArgs};
 use log::{error, info, warn};
 use tauri::AppHandle;
@@ -34,7 +34,7 @@ pub async fn handle_object_fal(
     None => {
       error!("No FAL API key is set. Can't perform action.");
       let event =
-          GenerationEnqueueFailureEvent::no_fal_api_key(GenerationAction::GenerateImage);
+          GenerationEnqueueFailureEvent::no_fal_api_key(GenerationAction::ImageTo3d);
 
       if let Err(err) = event.send(&app) {
         error!("Failed to emit event: {:?}", err); // Fail open.

crates/desktop/artcraft/src/core/commands/enqueue/object/internal_object_error.rs

@@ -1,7 +1,7 @@
+use crate::core::artcraft_error::ArtcraftError;
 use base64::DecodeError;
 use errors::AnyhowError;
 use fal_client::error::fal_error_plus::FalErrorPlus;
-use storyteller_client::error::api_error::ApiError;
 use storyteller_client::error::storyteller_error::StorytellerError;
 
 #[derive(Debug)]
@@ -13,9 +13,9 @@ pub enum InternalObjectError {
   FalError(FalErrorPlus),
   AnyhowError(AnyhowError),
   StorytellerError(StorytellerError),
-  StorytellerApiError(ApiError),
   DecodeError(DecodeError),
   IoError(std::io::Error),
+  ArtcraftError(ArtcraftError),
 }
 
 impl From<AnyhowError> for InternalObjectError {
@@ -30,9 +30,9 @@ impl From<FalErrorPlus> for InternalObjectError {
   }
 }
 
-impl From<ApiError> for InternalObjectError {
-  fn from(value: ApiError) -> Self {
-    Self::StorytellerApiError(value)
+impl From<StorytellerError> for InternalObjectError {
+  fn from(value: StorytellerError) -> Self {
+    Self::StorytellerError(value)
   }
 }
 
@@ -47,3 +47,15 @@ impl From<std::io::Error> for InternalObjectError {
     Self::IoError(value)
   }
 }
+
+impl From<ArtcraftError> for InternalObjectError {
+  fn from(value: ArtcraftError) -> Self {
+    match value {
+      ArtcraftError::AnyhowError(e) => Self::AnyhowError(e),
+      ArtcraftError::DecodeError(e) => Self::DecodeError(e),
+      ArtcraftError::IoError(e) => Self::IoError(e),
+      ArtcraftError::StorytellerError(e) => Self::StorytellerError(e),
+      _ => Self::ArtcraftError(value),
+    }
+  }
+}

crates/desktop/artcraft/src/core/commands/enqueue/video/enqueue_image_to_video_command.rs

@@ -0,0 +1,179 @@
+use crate::core::commands::enqueue::object::handle_object_artcraft::handle_object_artcraft;
+use crate::core::commands::enqueue::object::handle_object_fal::handle_object_fal;
+use crate::core::commands::enqueue::video::handle_video_artcraft::handle_video_artcraft;
+use crate::core::commands::enqueue::video::handle_video_fal::handle_video_fal;
+use crate::core::commands::enqueue::video::internal_video_error::InternalVideoError;
+use crate::core::commands::response::failure_response_wrapper::{CommandErrorResponseWrapper, CommandErrorStatus};
+use crate::core::commands::response::shorthand::Response;
+use crate::core::commands::response::success_response_wrapper::SerializeMarker;
+use crate::core::events::sendable_event_trait::SendableEvent;
+use crate::core::state::data_dir::app_data_root::AppDataRoot;
+use crate::core::state::data_dir::trait_data_subdir::DataSubdir;
+use crate::core::utils::download_media_file_to_temp_dir::download_media_file_to_temp_dir;
+use crate::core::utils::get_url_file_extension::get_url_file_extension;
+use crate::core::utils::save_base64_image_to_temp_dir::save_base64_image_to_temp_dir;
+use crate::core::utils::simple_http_download::simple_http_download;
+use crate::core::utils::simple_http_download_to_tempfile::simple_http_download_to_tempfile;
+use crate::services::fal::state::fal_credential_manager::FalCredentialManager;
+use crate::services::fal::state::fal_task_queue::FalTaskQueue;
+use crate::services::sora::state::read_sora_credentials_from_disk::read_sora_credentials_from_disk;
+use crate::services::sora::state::sora_credential_holder::SoraCredentialHolder;
+use crate::services::sora::state::sora_credential_manager::SoraCredentialManager;
+use crate::services::sora::state::sora_task_queue::SoraTaskQueue;
+use crate::services::storyteller::state::storyteller_credential_manager::StorytellerCredentialManager;
+use anyhow::anyhow;
+use base64::prelude::BASE64_STANDARD;
+use base64::{DecodeError, Engine};
+use errors::{AnyhowError, AnyhowResult};
+use fal_client::error::fal_error_plus::FalErrorPlus;
+use fal_client::requests::queue::image_gen::enqueue_flux_pro_11_ultra_text_to_image::{enqueue_flux_pro_11_ultra_text_to_image, FluxPro11UltraTextToImageArgs};
+use fal_client::requests::queue::image_gen::enqueue_recraft3_text_to_image::{enqueue_recraft3_text_to_image, Recraft3TextToImageArgs};
+use filesys::file_read_bytes::file_read_bytes;
+use image::codecs::png::{CompressionType, FilterType, PngEncoder};
+use image::{DynamicImage, EncodableLayout, ImageReader};
+use log::{debug, error, info, warn};
+use mimetypes::mimetype_info::mimetype_info::MimetypeInfo;
+use openai_sora_client::credentials::SoraCredentials;
+use openai_sora_client::creds::credential_migration::CredentialMigrationRef;
+use openai_sora_client::recipes::image_remix_with_session_auto_renew::{image_remix_with_session_auto_renew, ImageRemixAutoRenewRequest};
+use openai_sora_client::recipes::image_upload_from_file_with_session_auto_renew::{image_upload_from_file_with_session_auto_renew, ImageUploadFromFileAutoRenewRequest};
+use openai_sora_client::recipes::maybe_upgrade_or_renew_session::maybe_upgrade_or_renew_session;
+use openai_sora_client::requests::image_gen::common::{ImageSize, NumImages};
+use openai_sora_client::requests::image_gen::sora_image_gen_remix::{sora_image_gen_remix, SoraImageGenRemixRequest};
+use openai_sora_client::requests::upload::upload_media_from_bytes::sora_media_upload_from_bytes;
+use openai_sora_client::requests::upload::upload_media_from_file::sora_media_upload_from_file;
+use openai_sora_client::sora_error::SoraError;
+use reqwest::Url;
+use serde_derive::{Deserialize, Serialize};
+use std::fs::read_to_string;
+use std::io::{Cursor, Read, Write};
+use std::ops::Add;
+use std::path::PathBuf;
+use std::time::Duration;
+use storyteller_client::error::api_error::ApiError;
+use storyteller_client::error::api_error::ApiError::InternalServerError;
+use storyteller_client::media_files::get_media_file::{get_media_file, GetMediaFileSuccessResponse};
+use storyteller_client::media_files::upload_image_media_file_from_file::upload_image_media_file_from_file;
+use storyteller_client::utils::api_host::ApiHost;
+use tauri::{AppHandle, Emitter, Manager, State};
+use tempfile::NamedTempFile;
+use tokens::tokens::media_files::MediaFileToken;
+
+#[derive(Deserialize)]
+pub struct EnqueueImageToVideoRequest {
+  /// Image media file; the image to remove the background from.
+  /// TODO: In the future we may support base64 images, URLs, or file paths here.
+  pub image_media_token: Option<MediaFileToken>,
+  
+  /// The model to use.
+  pub model: Option<EnqueueImageToVideoModel>,
+}
+
+#[derive(Deserialize, Debug, Copy, Clone)]
+#[serde(rename_all = "snake_case")]
+pub enum EnqueueImageToVideoModel {
+  #[serde(rename = "kling1_6")]
+  Kling16,
+}
+
+#[derive(Serialize)]
+pub struct EnqueueImageToVideoSuccessResponse {
+}
+
+impl SerializeMarker for EnqueueImageToVideoSuccessResponse {}
+
+#[derive(Serialize, Debug)]
+#[serde(rename_all = "snake_case")]
+pub enum EnqueueImageToVideoErrorType {
+  /// Caller didn't specify a model
+  ModelNotSpecified,
+  /// Generic server error
+  ServerError,
+  /// No Fal API key available
+  NeedsFalApiKey,
+  /// Fal had an API error
+  FalError,
+  /// Needs to be logged into Artcraft
+  NeedsStorytellerCredentials,
+}
+
+#[tauri::command]
+pub async fn enqueue_image_to_video_command(
+  app: AppHandle,
+  request: EnqueueImageToVideoRequest,
+  app_data_root: State<'_, AppDataRoot>,
+  fal_creds_manager: State<'_, FalCredentialManager>,
+  fal_task_queue: State<'_, FalTaskQueue>,
+  storyteller_creds_manager: State<'_, StorytellerCredentialManager>,
+  sora_task_queue: State<'_, SoraTaskQueue>,
+) -> Response<EnqueueImageToVideoSuccessResponse, EnqueueImageToVideoErrorType, ()> {
+
+  info!("enqueue_image_to_video_command called");
+
+  let result = handle_request(
+    &app,
+    request,
+    &app_data_root,
+    &fal_creds_manager,
+    &storyteller_creds_manager,
+    &fal_task_queue,
+  ).await;
+
+  match result {
+    Err(err) => {
+      error!("error: {:?}", err);
+
+      let mut status = CommandErrorStatus::ServerError;
+      let mut error_type = EnqueueImageToVideoErrorType::ServerError;
+      let mut error_message = "A server error occurred. Please try again. If it continues, please tell our staff about the problem.";
+
+      match err {
+        InternalVideoError::NoModelSpecified => {
+          status = CommandErrorStatus::BadRequest;
+          error_type = EnqueueImageToVideoErrorType::ModelNotSpecified;
+          error_message = "No model specified for image generation";
+        }
+        InternalVideoError::NeedsFalApiKey => {
+          status = CommandErrorStatus::Unauthorized;
+          error_type = EnqueueImageToVideoErrorType::NeedsFalApiKey;
+          error_message = "You need to set a FAL api key";
+        },
+        InternalVideoError::NeedsStorytellerCredentials => {
+          status = CommandErrorStatus::Unauthorized;
+          error_type = EnqueueImageToVideoErrorType::NeedsStorytellerCredentials;
+          error_message = "You need to be logged into Artcraft.";
+        }
+        _ => {}, // Fall-through
+      }
+
+      Err(CommandErrorResponseWrapper {
+        status,
+        error_message: Some(error_message.to_string()),
+        error_type: Some(error_type),
+        error_details: None,
+      })
+    }
+    Ok(()) => {
+      Ok(EnqueueImageToVideoSuccessResponse {}.into())
+    }
+  }
+}
+
+
+pub async fn handle_request(
+  app: &AppHandle,
+  request: EnqueueImageToVideoRequest,
+  app_data_root: &AppDataRoot,
+  fal_creds_manager: &FalCredentialManager,
+  storyteller_creds_manager: &StorytellerCredentialManager,
+  fal_task_queue: &FalTaskQueue,
+) -> Result<(), InternalVideoError> {
+
+  if fal_creds_manager.has_apparent_api_token()? {
+    handle_video_fal(&app, app_data_root, request, fal_creds_manager, fal_task_queue).await?;
+  } else {
+    handle_video_artcraft(request, &app, app_data_root, storyteller_creds_manager).await?;
+  }
+
+  Ok(())
+}

crates/desktop/artcraft/src/core/commands/enqueue/video/handle_video_artcraft.rs

@@ -0,0 +1,138 @@
+use crate::core::commands::enqueue::image::enqueue_text_to_image_command::{EnqueueTextToImageModel, EnqueueTextToImageRequest};
+use crate::core::commands::enqueue::object::enqueue_image_to_3d_object_command::{EnqueueImageTo3dObjectModel, EnqueueImageTo3dObjectRequest};
+use crate::core::commands::enqueue::video::enqueue_image_to_video_command::{EnqueueImageToVideoModel, EnqueueImageToVideoRequest};
+use crate::core::commands::enqueue::video::internal_video_error::InternalVideoError;
+use crate::core::events::basic_sendable_event_trait::BasicSendableEvent;
+use crate::core::events::generation_events::common::{GenerationAction, GenerationModel, GenerationServiceProvider};
+use crate::core::events::generation_events::generation_enqueue_failure_event::GenerationEnqueueFailureEvent;
+use crate::core::events::generation_events::generation_enqueue_success_event::GenerationEnqueueSuccessEvent;
+use crate::core::state::data_dir::app_data_root::AppDataRoot;
+use crate::core::utils::download_media_file_to_temp_dir::download_media_file_to_temp_dir;
+use crate::core::utils::save_base64_image_to_temp_dir::save_base64_image_to_temp_dir;
+use crate::services::fal::state::fal_credential_manager::FalCredentialManager;
+use crate::services::fal::state::fal_task_queue::FalTaskQueue;
+use crate::services::sora::state::sora_credential_manager::SoraCredentialManager;
+use crate::services::sora::state::sora_task_queue::SoraTaskQueue;
+use crate::services::storyteller::state::storyteller_credential_manager::StorytellerCredentialManager;
+use anyhow::anyhow;
+use artcraft_api_defs::generate::object::generate_hunyuan_2_image_to_3d::GenerateHunyuan2ImageTo3dRequest;
+use artcraft_api_defs::generate::video::generate_kling_1_6_pro_image_to_video::{GenerateKling16ProAspectRatio, GenerateKling16ProImageToVideoRequest};
+use fal_client::creds::fal_api_key::FalApiKey;
+use fal_client::requests::queue::enqueue_hunyuan2_image_to_3d::{enqueue_hunyuan2_image_to_3d, Hunyuan2Args};
+use fal_client::requests::queue::image_gen::enqueue_flux_pro_11_ultra_text_to_image::{enqueue_flux_pro_11_ultra_text_to_image, FluxPro11UltraTextToImageArgs};
+use fal_client::requests::queue::image_gen::enqueue_recraft3_text_to_image::{enqueue_recraft3_text_to_image, Recraft3TextToImageArgs};
+use fal_client::requests::queue::video_gen::enqueue_kling_16_pro_image_to_video::Kling16ProAspectRatio;
+use idempotency::uuid::generate_random_uuid;
+use log::{error, info, warn};
+use storyteller_client::generate::object::generate_hunyuan2_image_to_3d::generate_hunyuan2_image_to_3d;
+use storyteller_client::generate::video::generate_kling_16_pro_image_to_video::generate_kling_16_pro_image_to_video;
+use storyteller_client::utils::api_host::ApiHost;
+use tauri::{AppHandle, State};
+
+pub async fn handle_video_artcraft(
+  request: EnqueueImageToVideoRequest,
+  app: &AppHandle,
+  app_data_root: &AppDataRoot,
+  storyteller_creds_manager: &StorytellerCredentialManager,
+) -> Result<(), InternalVideoError> {
+
+  let creds = match storyteller_creds_manager.get_credentials()? {
+    Some(creds) => creds,
+    None => {
+      error!("No Artcraft credentials are set. Can't perform action.");
+      let event =
+          GenerationEnqueueFailureEvent::no_artcraft_credentials(GenerationAction::GenerateVideo);
+
+      if let Err(err) = event.send(&app) {
+        error!("Failed to emit event: {:?}", err); // Fail open.
+      }
+      
+      return Err(InternalVideoError::NeedsStorytellerCredentials);
+    },
+  };
+  
+  //let api_key = fal_creds_manager.get_key_required()
+  //    .map_err(|err| {
+  //      error!("EnqueueTextToImage FAL api key required: {:?}", err);
+  //      InternalVideoError::NeedsFalApiKey
+  //    })?;
+
+
+  info!("Calling Artcraft image to video...");
+
+
+  let uuid_idempotency_token = generate_random_uuid();
+  
+  let mut selected_model = None;
+  
+  let job_token = match request.model {
+    None => {
+      return Err(InternalVideoError::NoModelSpecified);
+    }
+    Some(EnqueueImageToVideoModel::Kling16) => {
+      info!("enqueue Kling 1.6");
+      selected_model = Some(GenerationModel::Kling1_6);
+      let request = GenerateKling16ProImageToVideoRequest { 
+        uuid_idempotency_token,
+        media_file_token: request.image_media_token,
+        aspect_ratio: Some(GenerateKling16ProAspectRatio::WideSixteenNine),
+        prompt: None,
+      };
+      let result = generate_kling_16_pro_image_to_video(
+        &ApiHost::Storyteller,
+        Some(&creds),
+        request,
+      ).await;
+      match result {
+        Ok(enqueued) => {
+          info!("Successfully enqueued Artcraft Kling 1.6 video generation");
+          enqueued.inference_job_token
+        }
+        Err(err) => {
+          error!("Failed to use Artcraft Kling 1.6 video generation: {:?}", err);
+          return Err(InternalVideoError::StorytellerError(err));
+        }
+      }
+    }
+  };
+
+  info!("Successfully enqueued video generation");
+  
+  let event = GenerationEnqueueSuccessEvent {
+    action: GenerationAction::GenerateVideo,
+    service: GenerationServiceProvider::Artcraft,
+    model: selected_model,
+  };
+  
+  if let Err(err) = event.send(app) {
+    error!("Failed to emit event: {:?}", err); // Fail open.
+  }
+  
+  //if let Err(err) = fal_task_queue.insert(&enqueued) {
+  //  error!("Failed to enqueue task: {:?}", err);
+  //  return Err(InternalVideoError::AnyhowError(anyhow!("Failed to enqueue task: {:?}", err)));
+  //}
+
+//  match result {
+//    Ok(enqueued) => {
+//    }
+//    Err(err) => {
+//      error!("Failed to enqueue image to 3d: {:?}", err);
+//
+//      let event = GenerationEnqueueFailureEvent {
+//        action: GenerationAction::ImageTo3d,
+//        service: GenerationServiceProvider::Fal,
+//        model: None,
+//        reason: None,
+//      };
+//
+//      if let Err(err) = event.send(app) {
+//        error!("Failed to emit event: {:?}", err); // Fail open.
+//      }
+//
+//      return Err(InternalVideoError::FalError(err));
+//    }
+//  }
+
+  Ok(())
+}

crates/desktop/artcraft/src/core/commands/enqueue/video/handle_video_fal.rs

@@ -0,0 +1,124 @@
+use crate::core::commands::enqueue::image::enqueue_text_to_image_command::{EnqueueTextToImageModel, EnqueueTextToImageRequest};
+use crate::core::commands::enqueue::video::enqueue_image_to_video_command::{EnqueueImageToVideoModel, EnqueueImageToVideoRequest};
+use crate::core::commands::enqueue::video::internal_video_error::InternalVideoError;
+use crate::core::events::basic_sendable_event_trait::BasicSendableEvent;
+use crate::core::events::generation_events::common::{GenerationAction, GenerationModel, GenerationServiceProvider};
+use crate::core::events::generation_events::generation_enqueue_failure_event::GenerationEnqueueFailureEvent;
+use crate::core::events::generation_events::generation_enqueue_success_event::GenerationEnqueueSuccessEvent;
+use crate::core::state::data_dir::app_data_root::AppDataRoot;
+use crate::core::utils::download_media_file_to_temp_dir::download_media_file_to_temp_dir;
+use crate::core::utils::save_base64_image_to_temp_dir::save_base64_image_to_temp_dir;
+use crate::services::fal::state::fal_credential_manager::FalCredentialManager;
+use crate::services::fal::state::fal_task_queue::FalTaskQueue;
+use crate::services::sora::state::sora_credential_manager::SoraCredentialManager;
+use crate::services::sora::state::sora_task_queue::SoraTaskQueue;
+use crate::services::storyteller::state::storyteller_credential_manager::StorytellerCredentialManager;
+use anyhow::anyhow;
+use fal_client::creds::fal_api_key::FalApiKey;
+use fal_client::requests::queue::enqueue_hunyuan2_image_to_3d::{enqueue_hunyuan2_image_to_3d, Hunyuan2Args};
+use fal_client::requests::queue::image_gen::enqueue_flux_pro_11_ultra_text_to_image::{enqueue_flux_pro_11_ultra_text_to_image, FluxPro11UltraTextToImageArgs};
+use fal_client::requests::queue::image_gen::enqueue_recraft3_text_to_image::{enqueue_recraft3_text_to_image, Recraft3TextToImageArgs};
+use fal_client::requests::queue::video_gen::enqueue_kling_16_pro_image_to_video::{enqueue_kling_16_pro_image_to_video, Kling16ProArgs, Kling16ProAspectRatio, Kling16ProDuration};
+use log::{error, info, warn};
+use tauri::AppHandle;
+
+pub async fn handle_video_fal(
+  app: &AppHandle,
+  app_data_root: &AppDataRoot,
+  request: EnqueueImageToVideoRequest,
+  fal_creds_manager: &FalCredentialManager,
+  fal_task_queue: &FalTaskQueue,
+) -> Result<(), InternalVideoError> {
+
+  let api_key = match fal_creds_manager.get_key()? {
+    Some(key) => key,
+    None => {
+      error!("No FAL API key is set. Can't perform action.");
+      let event =
+          GenerationEnqueueFailureEvent::no_fal_api_key(GenerationAction::GenerateVideo);
+
+      if let Err(err) = event.send(&app) {
+        error!("Failed to emit event: {:?}", err); // Fail open.
+      }
+      
+      return Err(InternalVideoError::NeedsFalApiKey);
+    },
+  };
+  
+  //let api_key = fal_creds_manager.get_key_required()
+  //    .map_err(|err| {
+  //      error!("EnqueueTextToImage FAL api key required: {:?}", err);
+  //      InternalVideoError::NeedsFalApiKey
+  //    })?;
+
+  let mut temp_download;
+
+  if let Some(media_token) = request.image_media_token {
+    temp_download = download_media_file_to_temp_dir(&app_data_root, &media_token).await?;
+
+  } else {
+    return Err(InternalVideoError::AnyhowError(anyhow!("No image media token provided")));
+  }
+
+  info!("Calling FAL image to 3d ...");
+
+  let filename = temp_download.path().to_path_buf();
+  
+  let mut selected_model = None;
+
+  let result = match request.model {
+    None => {
+      return Err(InternalVideoError::NoModelSpecified);
+    }
+    Some(EnqueueImageToVideoModel::Kling16) => {
+      info!("enqueue Kling 1.6 image to video");
+      selected_model = Some(GenerationModel::Kling1_6);
+      enqueue_kling_16_pro_image_to_video(Kling16ProArgs {
+        image_path: filename,
+        api_key: &api_key,
+        duration: Kling16ProDuration::Default,
+        aspect_ratio: Kling16ProAspectRatio::WideSixteenNine,
+        prompt: "",
+      }).await
+    }
+  };
+
+  match result {
+    Ok(enqueued) => {
+      info!("Successfully enqueued Kling 1.6 image to video");
+
+      let event = GenerationEnqueueSuccessEvent {
+        action: GenerationAction::GenerateVideo,
+        service: GenerationServiceProvider::Fal,
+        model: selected_model,
+      };
+
+      if let Err(err) = event.send(app) {
+        error!("Failed to emit event: {:?}", err); // Fail open.
+      }
+
+      if let Err(err) = fal_task_queue.insert(&enqueued) {
+        error!("Failed to enqueue task: {:?}", err);
+        return Err(InternalVideoError::AnyhowError(anyhow!("Failed to enqueue task: {:?}", err)));
+      }
+    }
+    Err(err) => {
+      error!("Failed to enqueue image to video: {:?}", err);
+
+      let event = GenerationEnqueueFailureEvent {
+        action: GenerationAction::GenerateVideo,
+        service: GenerationServiceProvider::Fal,
+        model: selected_model,
+        reason: None,
+      };
+
+      if let Err(err) = event.send(app) {
+        error!("Failed to emit event: {:?}", err); // Fail open.
+      }
+
+      return Err(InternalVideoError::FalError(err));
+    }
+  }
+
+  Ok(())
+}

crates/desktop/artcraft/src/core/commands/enqueue/video/internal_video_error.rs

@@ -0,0 +1,61 @@
+use crate::core::artcraft_error::ArtcraftError;
+use base64::DecodeError;
+use errors::AnyhowError;
+use fal_client::error::fal_error_plus::FalErrorPlus;
+use storyteller_client::error::storyteller_error::StorytellerError;
+
+#[derive(Debug)]
+pub enum InternalVideoError {
+  NoModelSpecified,
+  NeedsFalApiKey,
+  NeedsSoraCredentials,
+  NeedsStorytellerCredentials,
+  FalError(FalErrorPlus),
+  AnyhowError(AnyhowError),
+  StorytellerError(StorytellerError),
+  DecodeError(DecodeError),
+  IoError(std::io::Error),
+  ArtcraftError(ArtcraftError),
+}
+
+impl From<AnyhowError> for InternalVideoError {
+  fn from(value: AnyhowError) -> Self {
+    Self::AnyhowError(value)
+  }
+}
+
+impl From<FalErrorPlus> for InternalVideoError {
+  fn from(value: FalErrorPlus) -> Self {
+    Self::FalError(value)
+  }
+}
+
+impl From<StorytellerError> for InternalVideoError {
+  fn from(value: StorytellerError) -> Self {
+    Self::StorytellerError(value)
+  }
+}
+
+impl From<DecodeError> for InternalVideoError {
+  fn from(value: DecodeError) -> Self {
+    Self::DecodeError(value)
+  }
+}
+
+impl From<std::io::Error> for InternalVideoError {
+  fn from(value: std::io::Error) -> Self {
+    Self::IoError(value)
+  }
+}
+
+impl From<ArtcraftError> for InternalVideoError {
+  fn from(value: ArtcraftError) -> Self {
+    match value {
+      ArtcraftError::AnyhowError(e) => Self::AnyhowError(e),
+      ArtcraftError::DecodeError(e) => Self::DecodeError(e),
+      ArtcraftError::IoError(e) => Self::IoError(e),
+      ArtcraftError::StorytellerError(e) => Self::StorytellerError(e),
+      _ => Self::ArtcraftError(value),
+    }
+  }
+}

crates/desktop/artcraft/src/core/commands/enqueue/video/mod.rs

@@ -0,0 +1,4 @@
+pub mod enqueue_image_to_video_command;
+pub mod handle_video_artcraft;
+pub mod handle_video_fal;
+pub mod internal_video_error;

crates/desktop/artcraft/src/core/events/generation_events/common.rs

@@ -11,6 +11,8 @@ pub enum GenerationServiceProvider {
 #[derive(Debug, Copy, Clone, Serialize)]
 #[serde(rename_all = "snake_case")]
 pub enum GenerationModel {
+  #[serde(rename = "flux_pro_1.1_ultra")]
+  FluxPro11Ultra,
   #[serde(rename = "kling_1.6")]
   Kling1_6,
   #[serde(rename = "kling_2.0")]

crates/desktop/artcraft/src/core/mod.rs

@@ -1,3 +1,4 @@
+pub mod artcraft_error;
 pub mod commands;
 pub mod events;
 pub mod state;

crates/desktop/artcraft/src/core/state/data_dir/app_data_root.rs

@@ -33,6 +33,7 @@ pub struct AppDataRoot {
 impl AppDataRoot {
   pub fn create_default() -> anyhow::Result<Self> {
     let directory = get_default_data_dir()?;
+    println!("App data directory: {:?}", directory);
     Self::create_existing(directory)
   }
 

crates/desktop/artcraft/src/core/utils/download_media_file_to_temp_dir.rs

@@ -1,7 +1,7 @@
+use crate::core::artcraft_error::ArtcraftError;
 use crate::core::state::data_dir::app_data_root::AppDataRoot;
 use crate::core::utils::get_url_file_extension::get_url_file_extension;
 use crate::core::utils::simple_http_download_to_tempfile::simple_http_download_to_tempfile;
-use errors::AnyhowResult;
 use storyteller_client::media_files::get_media_file::get_media_file;
 use storyteller_client::utils::api_host::ApiHost;
 use tempfile::NamedTempFile;
@@ -9,7 +9,7 @@ use tokens::tokens::media_files::MediaFileToken;
 
 // TODO: Better more concrete error handling
 
-pub async fn download_media_file_to_temp_dir(app_data_root: &AppDataRoot, token: &MediaFileToken) -> AnyhowResult<NamedTempFile> {
+pub async fn download_media_file_to_temp_dir(app_data_root: &AppDataRoot, token: &MediaFileToken) -> Result<NamedTempFile, ArtcraftError> {
   let response = get_media_file(&ApiHost::Storyteller, token).await?;
 
   let media_file_url = &response.media_file.media_links.cdn_url;

crates/desktop/artcraft/src/core/utils/save_base64_image_to_temp_dir.rs

@@ -1,15 +1,12 @@
+use crate::core::artcraft_error::ArtcraftError;
 use crate::core::state::data_dir::app_data_root::AppDataRoot;
-use base64::prelude::BASE64_STANDARD;
-use base64::Engine;
-use errors::AnyhowResult;
 use mimetypes::mimetype_info::mimetype_info::MimetypeInfo;
 use std::io::Write;
 use tempfile::NamedTempFile;
+use web_base64::web_base64_decode::web_base64_decode;
 
-// TODO: Retain error types (io/decode)
-
-pub async fn save_base64_image_to_temp_dir(app_data_root: &AppDataRoot, base64_image: String) -> AnyhowResult<NamedTempFile> {
-  let bytes = BASE64_STANDARD.decode(base64_image)?;
+pub async fn save_base64_image_to_temp_dir(app_data_root: &AppDataRoot, base64_image: String) -> Result<NamedTempFile, ArtcraftError> {
+  let bytes = web_base64_decode(&base64_image)?;
 
   let extension = MimetypeInfo::get_for_bytes(&bytes)
       .map(|info| info.file_extension())

crates/desktop/artcraft/src/lib.rs

@@ -7,6 +7,7 @@ use crate::core::commands::app_preferences::get_app_preferences_command::get_app
 use crate::core::commands::app_preferences::update_app_preference_command::update_app_preferences_command;
 use crate::core::commands::enqueue::image::enqueue_text_to_image_command::enqueue_text_to_image_command;
 use crate::core::commands::enqueue::object::enqueue_image_to_3d_object_command::enqueue_image_to_3d_object_command;
+use crate::core::commands::enqueue::video::enqueue_image_to_video_command::enqueue_image_to_video_command;
 use crate::core::commands::flip_image::flip_image;
 use crate::core::commands::get_build_info_command::get_build_info_command;
 use crate::core::commands::platform_info_command::platform_info_command;
@@ -163,6 +164,7 @@ pub fn run() {
     .invoke_handler(tauri::generate_handler![
       check_sora_session_command,
       enqueue_image_to_3d_object_command,
+      enqueue_image_to_video_command,
       enqueue_text_to_image_command,
       fal_background_removal_command,
       fal_hunyuan_image_to_3d_command,

crates/desktop/artcraft/src/services/fal/commands/fal_background_removal_command.rs

@@ -1,3 +1,4 @@
+use crate::core::artcraft_error::ArtcraftError;
 use crate::core::commands::response::failure_response_wrapper::{CommandErrorResponseWrapper, CommandErrorStatus};
 use crate::core::commands::response::shorthand::Response;
 use crate::core::commands::response::success_response_wrapper::SerializeMarker;
@@ -49,6 +50,7 @@ use std::path::PathBuf;
 use std::time::Duration;
 use storyteller_client::error::api_error::ApiError;
 use storyteller_client::error::api_error::ApiError::InternalServerError;
+use storyteller_client::error::storyteller_error::StorytellerError;
 use storyteller_client::media_files::get_media_file::{get_media_file, GetMediaFileSuccessResponse};
 use storyteller_client::media_files::upload_image_media_file_from_file::upload_image_media_file_from_file;
 use storyteller_client::utils::api_host::ApiHost;
@@ -176,9 +178,10 @@ pub async fn fal_background_removal_command(
 enum InnerError {
   FalError(FalErrorPlus),
   AnyhowError(AnyhowError),
-  StorytellerApiError(ApiError),
+  StorytellerError(StorytellerError),
   DecodeError(DecodeError),
   IoError(std::io::Error),
+  ArtcraftError(ArtcraftError),
 }
 
 impl From<AnyhowError> for InnerError {
@@ -193,9 +196,9 @@ impl From<FalErrorPlus> for InnerError {
   }
 }
 
-impl From<ApiError> for InnerError {
-  fn from(value: ApiError) -> Self {
-    Self::StorytellerApiError(value)
+impl From<StorytellerError> for InnerError {
+  fn from(value: StorytellerError) -> Self {
+    Self::StorytellerError(value)
   }
 }
 
@@ -211,6 +214,17 @@ impl From<std::io::Error> for InnerError {
   }
 }
 
+impl From<ArtcraftError> for InnerError {
+  fn from(value: ArtcraftError) -> Self {
+    match value {
+      ArtcraftError::AnyhowError(e) => Self::AnyhowError(e),
+      ArtcraftError::DecodeError(e) => Self::DecodeError(e),
+      ArtcraftError::IoError(e) => Self::IoError(e),
+      _ => Self::ArtcraftError(value),
+    }
+  }
+}
+
 pub async fn remove_background(
   request: FalBackgroundRemovalRequest,
   app_data_root: &AppDataRoot,
@@ -224,9 +238,11 @@ pub async fn remove_background(
   let mut temp_download;
   
   if let Some(media_token) = request.image_media_token {
+    info!("From media token: {:?}", &media_token);
     temp_download = download_media_file_to_temp_dir(&app_data_root, &media_token).await?;
     
   } else if let Some(base64_bytes) = request.base64_image {
+    info!("From base64 bytes...");
     temp_download = save_base64_image_to_temp_dir(&app_data_root, base64_bytes).await?;
   } else {
     return Err(InnerError::AnyhowError(anyhow!("No image media token or base64 image provided")));
@@ -237,6 +253,8 @@ pub async fn remove_background(
   let filename = temp_download.path().to_path_buf();
   
   let result = remove_background_rembg(filename, &api_key).await?;
+  
+  info!("Unpacking FAL result...");
 
   let extension_with_dot = get_url_file_extension(&result.image_url)
       .map(|ext| format!(".{}", ext))

crates/desktop/artcraft/src/services/fal/commands/fal_hunyuan_image_to_3d_command.rs

@@ -1,3 +1,4 @@
+use crate::core::artcraft_error::ArtcraftError;
 use crate::core::commands::response::failure_response_wrapper::{CommandErrorResponseWrapper, CommandErrorStatus};
 use crate::core::commands::response::shorthand::Response;
 use crate::core::events::basic_sendable_event_trait::BasicSendableEvent;
@@ -49,6 +50,7 @@ use std::path::PathBuf;
 use std::time::Duration;
 use storyteller_client::error::api_error::ApiError;
 use storyteller_client::error::api_error::ApiError::InternalServerError;
+use storyteller_client::error::storyteller_error::StorytellerError;
 use storyteller_client::media_files::get_media_file::{get_media_file, GetMediaFileSuccessResponse};
 use storyteller_client::media_files::upload_image_media_file_from_file::upload_image_media_file_from_file;
 use storyteller_client::utils::api_host::ApiHost;
@@ -152,9 +154,10 @@ pub async fn fal_hunyuan_image_to_3d_command(
 enum InnerError {
   FalError(FalErrorPlus),
   AnyhowError(AnyhowError),
-  StorytellerApiError(ApiError),
+  StorytellerError(StorytellerError),
   DecodeError(DecodeError),
   IoError(std::io::Error),
+  ArtcraftError(ArtcraftError),
 }
 
 impl From<AnyhowError> for InnerError {
@@ -169,9 +172,9 @@ impl From<FalErrorPlus> for InnerError {
   }
 }
 
-impl From<ApiError> for InnerError {
-  fn from(value: ApiError) -> Self {
-    Self::StorytellerApiError(value)
+impl From<StorytellerError> for InnerError {
+  fn from(value: StorytellerError) -> Self {
+    Self::StorytellerError(value)
   }
 }
 
@@ -187,6 +190,19 @@ impl From<std::io::Error> for InnerError {
   }
 }
 
+impl From<ArtcraftError> for InnerError {
+  fn from(value: ArtcraftError) -> Self {
+    match value {
+      ArtcraftError::AnyhowError(e) => Self::AnyhowError(e),
+      ArtcraftError::DecodeError(e) => Self::DecodeError(e),
+      ArtcraftError::IoError(e) => Self::IoError(e),
+      ArtcraftError::StorytellerError(e) => Self::StorytellerError(e),
+      _ => Self::ArtcraftError(value),
+    }
+  }
+}
+
+
 pub async fn image_to_3d(
   request: FalHunyuanImageTo3dRequest,
   app_data_root: &AppDataRoot,

crates/desktop/artcraft/src/services/fal/commands/fal_kling_image_to_video_command.rs

@@ -1,3 +1,4 @@
+use crate::core::artcraft_error::ArtcraftError;
 use crate::core::commands::response::failure_response_wrapper::{CommandErrorResponseWrapper, CommandErrorStatus};
 use crate::core::commands::response::shorthand::Response;
 use crate::core::events::basic_sendable_event_trait::BasicSendableEvent;
@@ -24,7 +25,7 @@ use base64::prelude::BASE64_STANDARD;
 use base64::{DecodeError, Engine};
 use errors::{AnyhowError, AnyhowResult};
 use fal_client::error::fal_error_plus::FalErrorPlus;
-use fal_client::requests::queue::video_gen::enqueue_kling_16_image_to_video::{enqueue_kling_16_image_to_video, Kling16Args, Kling16Duration};
+use fal_client::requests::queue::video_gen::enqueue_kling_16_pro_image_to_video::{enqueue_kling_16_pro_image_to_video, Kling16ProArgs, Kling16ProAspectRatio, Kling16ProDuration};
 use filesys::file_read_bytes::file_read_bytes;
 use image::codecs::png::{CompressionType, FilterType, PngEncoder};
 use image::{DynamicImage, EncodableLayout, ImageReader};
@@ -49,6 +50,7 @@ use std::path::PathBuf;
 use std::time::Duration;
 use storyteller_client::error::api_error::ApiError;
 use storyteller_client::error::api_error::ApiError::InternalServerError;
+use storyteller_client::error::storyteller_error::StorytellerError;
 use storyteller_client::media_files::get_media_file::{get_media_file, GetMediaFileSuccessResponse};
 use storyteller_client::media_files::upload_image_media_file_from_file::upload_image_media_file_from_file;
 use storyteller_client::utils::api_host::ApiHost;
@@ -157,9 +159,10 @@ pub async fn fal_kling_image_to_video_command(
 enum InnerError {
   FalError(FalErrorPlus),
   AnyhowError(AnyhowError),
-  StorytellerApiError(ApiError),
+  StorytellerError(StorytellerError),
   DecodeError(DecodeError),
   IoError(std::io::Error),
+  ArtcraftError(ArtcraftError),
 }
 
 impl From<AnyhowError> for InnerError {
@@ -174,9 +177,9 @@ impl From<FalErrorPlus> for InnerError {
   }
 }
 
-impl From<ApiError> for InnerError {
-  fn from(value: ApiError) -> Self {
-    Self::StorytellerApiError(value)
+impl From<StorytellerError> for InnerError {
+  fn from(value: StorytellerError) -> Self {
+    Self::StorytellerError(value)
   }
 }
 
@@ -192,6 +195,18 @@ impl From<std::io::Error> for InnerError {
   }
 }
 
+impl From<ArtcraftError> for InnerError {
+  fn from(value: ArtcraftError) -> Self {
+    match value {
+      ArtcraftError::AnyhowError(e) => Self::AnyhowError(e),
+      ArtcraftError::DecodeError(e) => Self::DecodeError(e),
+      ArtcraftError::IoError(e) => Self::IoError(e),
+      ArtcraftError::StorytellerError(e) => Self::StorytellerError(e),
+      _ => Self::ArtcraftError(value),
+    }
+  }
+}
+
 pub async fn image_to_video(
   request: FalKlingImageToVideoRequest,
   app_data_root: &AppDataRoot,
@@ -218,10 +233,11 @@ pub async fn image_to_video(
 
   let filename = temp_download.path().to_path_buf();
 
-  let enqueued = enqueue_kling_16_image_to_video(Kling16Args {
+  let enqueued = enqueue_kling_16_pro_image_to_video(Kling16ProArgs {
     image_path: filename,
     api_key: &api_key,
-    duration: Kling16Duration::Default,
+    duration: Kling16ProDuration::Default,
+    aspect_ratio: Kling16ProAspectRatio::WideSixteenNine,
     prompt: request.prompt.as_deref().unwrap_or(""),
   }).await?;
 

crates/desktop/artcraft/src/services/sora/commands/sora_image_remix_command.rs

@@ -39,6 +39,7 @@ use storyteller_client::error::api_error::ApiError::InternalServerError;
 use storyteller_client::media_files::get_media_file::get_media_file;
 use storyteller_client::utils::api_host::ApiHost;
 use tauri::{AppHandle, Emitter, Manager, State};
+use storyteller_client::error::storyteller_error::StorytellerError;
 use tokens::tokens::media_files::MediaFileToken;
 
 const SORA_IMAGE_UPLOAD_TIMEOUT: Duration = Duration::from_millis(1000 * 30); // 30 seconds
@@ -199,7 +200,7 @@ pub async fn sora_image_remix_command(
 enum InnerError {
   SoraError(SoraError),
   AnyhowError(AnyhowError),
-  StorytellerApiError(ApiError),
+  StorytellerError(StorytellerError),
 }
 
 impl From<AnyhowError> for InnerError {
@@ -214,9 +215,9 @@ impl From<SoraError> for InnerError {
   }
 }
 
-impl From<ApiError> for InnerError {
-  fn from(value: ApiError) -> Self {
-    Self::StorytellerApiError(value)
+impl From<StorytellerError> for InnerError {
+  fn from(value: StorytellerError) -> Self {
+    Self::StorytellerError(value)
   }
 }
 

crates/desktop/artcraft/tauri.conf.json

@@ -16,7 +16,8 @@
         "width": 2400,
         "height": 1300,
         "resizable": true,
-        "fullscreen": false
+        "fullscreen": false,
+        "dragDropEnabled": false
       }
     ],
     "security": {
@@ -33,7 +34,7 @@
           "https://www.googletagmanager.com",
           "ipc://localhost",
           "tauri://localhost"
-        ], 
+        ],
         "connect-src": [
           "'self'",
           "'unsafe-eval'",

crates/lib/api_clients/fal_client/Cargo.toml

@@ -23,6 +23,7 @@ errors = { workspace = true }
 # External
 anyhow = { workspace = true }
 futures = { workspace = true }
+log = { workspace = true }
 reqwest = { workspace = true }
 serde = { workspace = true }
 tokio = { workspace = true }

crates/lib/api_clients/fal_client/src/requests/queue/image_gen/enqueue_flux_pro_11_ultra_text_to_image.rs

@@ -7,22 +7,25 @@ use fal::endpoints::fal_ai::flux_pro::v1_1_ultra::FluxProUltraTextToImageInput;
 use futures::StreamExt;
 use std::io::Write;
 
-pub struct FluxProUltraTextToImageArgs<'a> {
+pub struct FluxPro11UltraTextToImageArgs<'a> {
   pub prompt: &'a str,
   pub api_key: &'a FalApiKey,
   // TODO: Size parameter
 }
 
-pub async fn enqueue_flux_pro_ultra_text_to_image(args: FluxProUltraTextToImageArgs<'_>) -> Result<EnqueuedRequest, FalErrorPlus> {
+pub async fn enqueue_flux_pro_11_ultra_text_to_image(args: FluxPro11UltraTextToImageArgs<'_>) -> Result<EnqueuedRequest, FalErrorPlus> {
   let request = FluxProUltraTextToImageInput {
     prompt: args.prompt.to_string(),
-    safety_tolerance: Some("5".to_string()), // 1 is most strict, 5 is most permissive
-    enable_safety_checker: Some(false),
-    num_images: Some(1), // Default is 1
-    output_format: Some("png".to_string()),
-    raw: Some(true), // Generate less processed, more natural-looking images. Default is false.
+    // Maybe expose
     aspect_ratio: None, // Default is "16:9"
+    num_images: Some(1), // Default is 1
     seed: None,
+    raw: Some(true), // Generate less processed, more natural-looking images. Default is false.
+    // Maybe abstract
+    enable_safety_checker: Some(false),
+    safety_tolerance: Some("5".to_string()), // 1 is most strict, 5 is most permissive
+    // Constants
+    output_format: Some("png".to_string()),
     sync_mode: None, // Synchronous / slow
   };
 
@@ -42,7 +45,7 @@ pub async fn enqueue_flux_pro_ultra_text_to_image(args: FluxProUltraTextToImageA
 #[cfg(test)]
 mod tests {
   use crate::creds::fal_api_key::FalApiKey;
-  use crate::requests::queue::image_gen::enqueue_flux_pro_ultra_text_to_image::{enqueue_flux_pro_ultra_text_to_image, FluxProUltraTextToImageArgs};
+  use crate::requests::queue::image_gen::enqueue_flux_pro_11_ultra_text_to_image::{enqueue_flux_pro_11_ultra_text_to_image, FluxPro11UltraTextToImageArgs};
   use errors::AnyhowResult;
   use std::fs::read_to_string;
 
@@ -54,12 +57,12 @@ mod tests {
 
     let api_key = FalApiKey::from_str(&secret);
     
-    let args = FluxProUltraTextToImageArgs {
+    let args = FluxPro11UltraTextToImageArgs {
       prompt: "a corgi smiles at the camera, inside retro video game store, lots of sci-fi props from Cowboy Bebop, photorealistic",
       api_key: &api_key,
     };
 
-    let result = enqueue_flux_pro_ultra_text_to_image(args).await?;
+    let result = enqueue_flux_pro_11_ultra_text_to_image(args).await?;
 
     Ok(())
   }

crates/lib/api_clients/fal_client/src/requests/queue/image_gen/mod.rs

@@ -1,2 +1,2 @@
-pub mod enqueue_flux_pro_ultra_text_to_image;
+pub mod enqueue_flux_pro_11_ultra_text_to_image;
 pub mod enqueue_recraft3_text_to_image;

crates/lib/api_clients/fal_client/src/requests/queue/remove_background_rembg.rs

@@ -22,7 +22,7 @@ pub async fn remove_background_rembg<P: AsRef<Path>>(image_path: P, api_key: &Fa
     crop_to_bbox: None,
     sync_mode: None
   };
-  
+
   let result = rembg(request)
       .with_api_key(&api_key.0)
       .queue()
@@ -56,6 +56,7 @@ mod tests {
   use crate::creds::fal_api_key::FalApiKey;
   use crate::requests::queue::remove_background_rembg::remove_background_rembg;
   use errors::AnyhowResult;
+  use std::fs::read_to_string;
   use testing::test_file_path::test_file_path;
 
   #[tokio::test]
@@ -63,9 +64,9 @@ mod tests {
   async fn test_remove_background_rembg() -> AnyhowResult<()> {
     let image = test_file_path("test_data/image/juno.jpg")?;
 
-    // TODO: DO NOT COMMIT SECRET !
-    const KEY : &str = "DO NOT COMMIT";
-    let api_key = FalApiKey::from_str(KEY);
+    // XXX: Don't commit secrets!
+    let secret = read_to_string("/Users/bt/Artcraft/credentials/fal_api_key.txt")?;
+    let api_key = FalApiKey::from_str(&secret);
 
     let result = remove_background_rembg(image, &api_key).await?;
 

crates/lib/api_clients/fal_client/src/requests/queue/video_gen/enqueue_kling_16_pro_image_to_video.rs

@@ -8,35 +8,50 @@ use futures::StreamExt;
 use std::io::Write;
 use std::path::Path;
 
-pub struct Kling16Args<'a, P: AsRef<Path>> {
+pub struct Kling16ProArgs<'a, P: AsRef<Path>> {
   pub image_path: P,
   pub prompt: &'a str,
   pub api_key: &'a FalApiKey,
-  pub duration: Kling16Duration,
+  pub duration: Kling16ProDuration,
+  pub aspect_ratio: Kling16ProAspectRatio,
 }
 
 #[derive(Copy, Clone, Debug)]
-pub enum Kling16Duration {
+pub enum Kling16ProDuration {
   Default,
   FiveSeconds,
   TenSeconds,
 }
 
-pub async fn enqueue_kling_16_image_to_video<P: AsRef<Path>>(args: Kling16Args<'_, P>) -> Result<EnqueuedRequest, FalErrorPlus> {
+#[derive(Copy, Clone, Debug)]
+pub enum Kling16ProAspectRatio {
+  Square, // 1:1
+  WideSixteenNine, // 16:9
+  TallNineSixteen, // 9:16
+}
+
+pub async fn enqueue_kling_16_pro_image_to_video<P: AsRef<Path>>(args: Kling16ProArgs<'_, P>) -> Result<EnqueuedRequest, FalErrorPlus> {
   let image_url = file_to_base64_url(args.image_path)?;
 
   let duration = match args.duration{
-    Kling16Duration::Default => None,
-    Kling16Duration::FiveSeconds => Some("5".to_string()), // Gross...
-    Kling16Duration::TenSeconds => Some("10".to_string()),
+    Kling16ProDuration::Default => None,
+    Kling16ProDuration::FiveSeconds => Some("5".to_string()), // Gross...
+    Kling16ProDuration::TenSeconds => Some("10".to_string()),
+  };
+  
+  let aspect_ratio = match args.aspect_ratio {
+    Kling16ProAspectRatio::Square => Some("1:1".to_string()),
+    Kling16ProAspectRatio::WideSixteenNine => Some("16:9".to_string()),
+    Kling16ProAspectRatio::TallNineSixteen => Some("9:16".to_string()),
   };
 
   let request = ProImageToVideoRequest {
     image_url,
     prompt: args.prompt.to_string(),
-    aspect_ratio: None,
-    cfg_scale: None,
+    aspect_ratio,
     duration,
+    // Maybe expose these later
+    cfg_scale: None,
     negative_prompt: None,
     tail_image_url: None,
   };
@@ -57,7 +72,7 @@ pub async fn enqueue_kling_16_image_to_video<P: AsRef<Path>>(args: Kling16Args<'
 #[cfg(test)]
 mod tests {
   use crate::creds::fal_api_key::FalApiKey;
-  use crate::requests::queue::video_gen::enqueue_kling_16_image_to_video::{enqueue_kling_16_image_to_video, Kling16Args, Kling16Duration};
+  use crate::requests::queue::video_gen::enqueue_kling_16_pro_image_to_video::{enqueue_kling_16_pro_image_to_video, Kling16ProArgs, Kling16ProAspectRatio, Kling16ProDuration};
   use errors::AnyhowResult;
   use std::fs::read_to_string;
   use testing::test_file_path::test_file_path;
@@ -72,14 +87,15 @@ mod tests {
 
     let api_key = FalApiKey::from_str(&secret);
 
-    let args = Kling16Args {
+    let args = Kling16ProArgs {
       image_path: image,
       prompt: "a corgi looks out over the water",
       api_key: &api_key,
-      duration: Kling16Duration::Default,
+      duration: Kling16ProDuration::Default,
+      aspect_ratio: Kling16ProAspectRatio::Square,
     };
 
-    let result = enqueue_kling_16_image_to_video(args).await?;
+    let result = enqueue_kling_16_pro_image_to_video(args).await?;
 
     Ok(())
   }

crates/lib/api_clients/fal_client/src/requests/queue/video_gen/mod.rs

@@ -1,2 +1,2 @@
-pub mod enqueue_kling_16_image_to_video;
+pub mod enqueue_kling_16_pro_image_to_video;
 pub mod enqueue_minimax_01_image_to_video;

crates/lib/api_clients/fal_client/src/requests/webhook/image/enqueue_flux_1_dev_text_to_image_webhook.rs

@@ -0,0 +1,106 @@
+use crate::creds::fal_api_key::FalApiKey;
+use crate::error::classify_fal_error::classify_fal_error;
+use crate::error::fal_error_plus::FalErrorPlus;
+use fal::endpoints::fal_ai::flux::dev::dev;
+use fal::endpoints::fal_ai::flux::dev::DevTextToImageInput;
+use fal::prelude::fal_ai::flux::dev::ImageSizeProperty;
+use fal::webhook::WebhookResponse;
+use reqwest::IntoUrl;
+
+pub struct Flux1DevArgs<'a, U: IntoUrl> {
+  pub prompt: &'a str,
+  pub webhook_url: U,
+  pub api_key: &'a FalApiKey,
+  pub aspect_ratio: Flux1DevAspectRatio,
+  pub num_images: Flux1DevNumImages,
+}
+
+#[derive(Copy, Clone, Debug)]
+pub enum Flux1DevAspectRatio {
+  Square, // 1:1
+  SquareHd, // 1:1
+  LandscapeFourByThree, // 4:3
+  LandscapeSixteenByNine, // 16:9
+  PortraitThreeByFour, // 3:4
+  PortraitNineBySixteen, // 9:16
+  //Custom { width: u32, height: u32 }, // TODO
+}
+
+#[derive(Copy, Clone, Debug)]
+pub enum Flux1DevNumImages {
+  One, // Default
+  Two,
+  Three,
+  Four,
+}
+
+pub async fn enqueue_flux_1_dev_text_to_image_webhook<U: IntoUrl>(
+  args: Flux1DevArgs<'_, U>
+) -> Result<WebhookResponse, FalErrorPlus> {
+  
+  let num_images = match args.num_images {
+    Flux1DevNumImages::One => 1,
+    Flux1DevNumImages::Two => 2,
+    Flux1DevNumImages::Three => 3,
+    Flux1DevNumImages::Four => 4,
+  };
+  
+  let image_size = match args.aspect_ratio {
+    Flux1DevAspectRatio::Square => ImageSizeProperty::Square,
+    Flux1DevAspectRatio::SquareHd => ImageSizeProperty::SquareHd,
+    Flux1DevAspectRatio::LandscapeFourByThree => ImageSizeProperty::Landscape43,
+    Flux1DevAspectRatio::LandscapeSixteenByNine => ImageSizeProperty::Landscape169,
+    Flux1DevAspectRatio::PortraitThreeByFour => ImageSizeProperty::Portrait43,
+    Flux1DevAspectRatio::PortraitNineBySixteen => ImageSizeProperty::Portrait169,
+  };
+  
+  let request = DevTextToImageInput {
+    prompt: args.prompt.to_string(),
+    num_images: Some(num_images),
+    image_size: Some(image_size),
+    // Maybe abstract
+    enable_safety_checker: Some(false),
+    // Maybe expose
+    seed: None,
+    guidance_scale: None,
+    num_inference_steps: None,
+    // Constants
+    sync_mode: None, // Synchronous / slow
+  };
+  
+  let result = dev(request)
+      .with_api_key(&args.api_key.0)
+      .queue_webhook(args.webhook_url)
+      .await;
+
+  result.map_err(|err| classify_fal_error(err))
+}
+
+#[cfg(test)]
+mod tests {
+  use crate::creds::fal_api_key::FalApiKey;
+  use crate::requests::webhook::image::enqueue_flux_1_dev_text_to_image_webhook::{enqueue_flux_1_dev_text_to_image_webhook, Flux1DevArgs, Flux1DevAspectRatio, Flux1DevNumImages};
+  use errors::AnyhowResult;
+  use std::fs::read_to_string;
+
+  #[tokio::test]
+  #[ignore]
+  async fn test_flux_1_dev() -> AnyhowResult<()> {
+    // XXX: Don't commit secrets!
+    let secret = read_to_string("/Users/bt/Artcraft/credentials/fal_api_key.txt")?;
+
+    let api_key = FalApiKey::from_str(&secret);
+
+    let args = Flux1DevArgs {
+      prompt: "a giant robot fighting a dragon in a futuristic city",
+      api_key: &api_key,
+      webhook_url: "https://example.com/webhook",
+      num_images: Flux1DevNumImages::One,
+      aspect_ratio: Flux1DevAspectRatio::LandscapeFourByThree
+    };
+
+    let result = enqueue_flux_1_dev_text_to_image_webhook(args).await?;
+
+    Ok(())
+  }
+}

crates/lib/api_clients/fal_client/src/requests/webhook/image/enqueue_flux_1_schnell_text_to_image_webhook.rs

@@ -0,0 +1,105 @@
+use crate::creds::fal_api_key::FalApiKey;
+use crate::error::classify_fal_error::classify_fal_error;
+use crate::error::fal_error_plus::FalErrorPlus;
+use fal::endpoints::fal_ai::flux::schnell::schnell;
+use fal::endpoints::fal_ai::flux::schnell::SchnellTextToImageInput;
+use fal::prelude::fal_ai::flux::schnell::ImageSizeProperty;
+use fal::webhook::WebhookResponse;
+use reqwest::IntoUrl;
+
+pub struct Flux1SchnellArgs<'a, U: IntoUrl> {
+  pub prompt: &'a str,
+  pub webhook_url: U,
+  pub api_key: &'a FalApiKey,
+  pub aspect_ratio: Flux1SchnellAspectRatio,
+  pub num_images: Flux1SchnellNumImages,
+}
+
+#[derive(Copy, Clone, Debug)]
+pub enum Flux1SchnellAspectRatio {
+  Square, // 1:1
+  SquareHd, // 1:1
+  LandscapeFourByThree, // 4:3
+  LandscapeSixteenByNine, // 16:9
+  PortraitThreeByFour, // 3:4
+  PortraitNineBySixteen, // 9:16
+  //Custom { width: u32, height: u32 }, // TODO
+}
+
+#[derive(Copy, Clone, Debug)]
+pub enum Flux1SchnellNumImages {
+  One, // Default
+  Two,
+  Three,
+  Four,
+}
+
+pub async fn enqueue_flux_1_schnell_text_to_image_webhook<U: IntoUrl>(
+  args: Flux1SchnellArgs<'_, U>
+) -> Result<WebhookResponse, FalErrorPlus> {
+  
+  let num_images = match args.num_images {
+    Flux1SchnellNumImages::One => 1,
+    Flux1SchnellNumImages::Two => 2,
+    Flux1SchnellNumImages::Three => 3,
+    Flux1SchnellNumImages::Four => 4,
+  };
+  
+  let image_size = match args.aspect_ratio {
+    Flux1SchnellAspectRatio::Square => ImageSizeProperty::Square,
+    Flux1SchnellAspectRatio::SquareHd => ImageSizeProperty::SquareHd,
+    Flux1SchnellAspectRatio::LandscapeFourByThree => ImageSizeProperty::Landscape43,
+    Flux1SchnellAspectRatio::LandscapeSixteenByNine => ImageSizeProperty::Landscape169,
+    Flux1SchnellAspectRatio::PortraitThreeByFour => ImageSizeProperty::Portrait43,
+    Flux1SchnellAspectRatio::PortraitNineBySixteen => ImageSizeProperty::Portrait169,
+  };
+  
+  let request = SchnellTextToImageInput {
+    prompt: args.prompt.to_string(),
+    num_images: Some(num_images),
+    image_size: Some(image_size),
+    // Maybe abstract
+    enable_safety_checker: Some(false),
+    // Maybe expose
+    seed: None,
+    num_inference_steps: None,
+    // Constants
+    sync_mode: None, // Synchronous / slow
+  };
+  
+  let result = schnell(request)
+      .with_api_key(&args.api_key.0)
+      .queue_webhook(args.webhook_url)
+      .await;
+
+  result.map_err(|err| classify_fal_error(err))
+}
+
+#[cfg(test)]
+mod tests {
+  use crate::creds::fal_api_key::FalApiKey;
+  use crate::requests::webhook::image::enqueue_flux_1_schnell_text_to_image_webhook::{enqueue_flux_1_schnell_text_to_image_webhook, Flux1SchnellArgs, Flux1SchnellAspectRatio, Flux1SchnellNumImages};
+  use errors::AnyhowResult;
+  use std::fs::read_to_string;
+
+  #[tokio::test]
+  #[ignore]
+  async fn test_flux_1_schnell() -> AnyhowResult<()> {
+    // XXX: Don't commit secrets!
+    let secret = read_to_string("/Users/bt/Artcraft/credentials/fal_api_key.txt")?;
+
+    let api_key = FalApiKey::from_str(&secret);
+
+    let args = Flux1SchnellArgs {
+      prompt: "a giant robot fighting a dragon in a futuristic city",
+      api_key: &api_key,
+      webhook_url: "https://example.com/webhook",
+      num_images: Flux1SchnellNumImages::One,
+      aspect_ratio: Flux1SchnellAspectRatio::LandscapeSixteenByNine,
+    };
+
+    let result = enqueue_flux_1_schnell_text_to_image_webhook(args).await?;
+
+    Ok(())
+  }
+}

crates/lib/api_clients/fal_client/src/requests/webhook/image/enqueue_flux_pro_11_text_to_image_webhook.rs

@@ -0,0 +1,104 @@
+use crate::creds::fal_api_key::FalApiKey;
+use crate::error::classify_fal_error::classify_fal_error;
+use crate::error::fal_error_plus::FalErrorPlus;
+use fal::endpoints::fal_ai::flux_pro::v1_1::{v1_1, FluxProPlusTextToImageInput, ImageSizeProperty};
+use fal::webhook::WebhookResponse;
+use reqwest::IntoUrl;
+
+pub struct FluxPro11Args<'a, U: IntoUrl> {
+  pub prompt: &'a str,
+  pub webhook_url: U,
+  pub api_key: &'a FalApiKey,
+  pub aspect_ratio: FluxPro11AspectRatio,
+  pub num_images: FluxPro11NumImages,
+}
+
+#[derive(Copy, Clone, Debug)]
+pub enum FluxPro11AspectRatio {
+  Square, // 1:1
+  SquareHd, // 1:1
+  LandscapeFourByThree, // 4:3
+  LandscapeSixteenByNine, // 16:9
+  PortraitThreeByFour, // 3:4
+  PortraitNineBySixteen, // 9:16
+  //Custom { width: u32, height: u32 }, // TODO
+}
+
+#[derive(Copy, Clone, Debug)]
+pub enum FluxPro11NumImages {
+  One, // Default
+  Two,
+  Three,
+  Four,
+}
+
+pub async fn enqueue_flux_pro_11_text_to_image_webhook<U: IntoUrl>(
+  args: FluxPro11Args<'_, U>
+) -> Result<WebhookResponse, FalErrorPlus> {
+  
+  let num_images = match args.num_images {
+    FluxPro11NumImages::One => 1,
+    FluxPro11NumImages::Two => 2,
+    FluxPro11NumImages::Three => 3,
+    FluxPro11NumImages::Four => 4,
+  };
+
+  let image_size = match args.aspect_ratio {
+    FluxPro11AspectRatio::Square => ImageSizeProperty::Square,
+    FluxPro11AspectRatio::SquareHd => ImageSizeProperty::SquareHd,
+    FluxPro11AspectRatio::LandscapeFourByThree => ImageSizeProperty::Landscape43,
+    FluxPro11AspectRatio::LandscapeSixteenByNine => ImageSizeProperty::Landscape169,
+    FluxPro11AspectRatio::PortraitThreeByFour => ImageSizeProperty::Portrait43,
+    FluxPro11AspectRatio::PortraitNineBySixteen => ImageSizeProperty::Portrait169,
+  };
+  
+  let request = FluxProPlusTextToImageInput {
+    prompt: args.prompt.to_string(),
+    num_images: Some(num_images),
+    image_size: Some(image_size),
+    // Maybe expose
+    seed: None,
+    // Maybe abstract
+    enable_safety_checker: Some(false),
+    safety_tolerance: Some("5".to_string()), // 1 is most strict, 5 is most permissive
+    // Constants
+    output_format: Some("png".to_string()),
+    sync_mode: None, // Synchronous / slow
+  };
+  
+  let result = v1_1(request)
+      .with_api_key(&args.api_key.0)
+      .queue_webhook(args.webhook_url)
+      .await;
+
+  result.map_err(|err| classify_fal_error(err))
+}
+
+#[cfg(test)]
+mod tests {
+  use crate::creds::fal_api_key::FalApiKey;
+  use crate::requests::webhook::image::enqueue_flux_pro_11_text_to_image_webhook::{enqueue_flux_pro_11_text_to_image_webhook, FluxPro11Args, FluxPro11AspectRatio, FluxPro11NumImages};
+  use errors::AnyhowResult;
+  use std::fs::read_to_string;
+
+  #[tokio::test]
+  #[ignore]
+  async fn test_flux_11_pro() -> AnyhowResult<()> {
+    // XXX: Don't commit secrets!
+    let secret = read_to_string("/Users/bt/Artcraft/credentials/fal_api_key.txt")?;
+
+    let api_key = FalApiKey::from_str(&secret);
+
+    let args = FluxPro11Args {
+      prompt: "a giant red panda fighting a dragon in a futuristic city",
+      api_key: &api_key,
+      webhook_url: "https://example.com/webhook",
+      num_images: FluxPro11NumImages::One,
+      aspect_ratio: FluxPro11AspectRatio::LandscapeSixteenByNine,
+    };
+
+    let result = enqueue_flux_pro_11_text_to_image_webhook(args).await?;
+
+    Ok(())
+  }
+}

crates/lib/api_clients/fal_client/src/requests/webhook/image/enqueue_flux_pro_11_ultra_text_to_image_webhook.rs

@@ -0,0 +1,39 @@
+use crate::creds::fal_api_key::FalApiKey;
+use crate::error::classify_fal_error::classify_fal_error;
+use crate::error::fal_error_plus::FalErrorPlus;
+use fal::endpoints::fal_ai::flux_pro::v1_1_ultra::{v1_1_ultra, FluxProUltraTextToImageInput};
+use fal::webhook::WebhookResponse;
+use reqwest::IntoUrl;
+
+pub struct FluxPro11UltraArgs<'a, U: IntoUrl> {
+  pub prompt: &'a str,
+  pub webhook_url: U,
+  pub api_key: &'a FalApiKey,
+}
+
+pub async fn enqueue_flux_pro_11_ultra_text_to_image_webhook<U: IntoUrl>(
+  args: FluxPro11UltraArgs<'_, U>
+) -> Result<WebhookResponse, FalErrorPlus> {
+  
+  let request = FluxProUltraTextToImageInput {
+    prompt: args.prompt.to_string(),
+    // Maybe expose
+    num_images: Some(1), // Default is 1
+    aspect_ratio: None, // Default is "16:9"
+    seed: None,
+    raw: Some(true), // Generate less processed, more natural-looking images. Default is false.
+    // Maybe abstract
+    enable_safety_checker: Some(false),
+    safety_tolerance: Some("5".to_string()), // 1 is most strict, 5 is most permissive
+    // Constants
+    output_format: Some("png".to_string()),
+    sync_mode: None, // Synchronous / slow
+  };
+  
+  let result = v1_1_ultra(request)
+      .with_api_key(&args.api_key.0)
+      .queue_webhook(args.webhook_url)
+      .await;
+
+  result.map_err(|err| classify_fal_error(err))
+}

crates/lib/api_clients/fal_client/src/requests/webhook/image/mod.rs

@@ -1 +1,5 @@
+pub mod enqueue_flux_1_dev_text_to_image_webhook;
+pub mod enqueue_flux_1_schnell_text_to_image_webhook;
+pub mod enqueue_flux_pro_11_text_to_image_webhook;
+pub mod enqueue_flux_pro_11_ultra_text_to_image_webhook;
 pub mod remove_background_rembg_webhook;

crates/lib/api_clients/fal_client/src/requests/webhook/object/enqueue_hunyuan_3d_21_image_to_3d_webhook.rs

@@ -0,0 +1,65 @@
+use crate::creds::fal_api_key::FalApiKey;
+use crate::error::classify_fal_error::classify_fal_error;
+use crate::error::fal_error_plus::FalErrorPlus;
+use fal::prelude::fal_ai::hunyuan3d::v21::{v21, Hunyuan3DInput};
+use fal::webhook::WebhookResponse;
+use reqwest::IntoUrl;
+
+pub struct Hunyuan3d21Args<'a, U: IntoUrl, V: IntoUrl> {
+  pub image_url: U,
+  pub webhook_url: V,
+  pub api_key: &'a FalApiKey,
+}
+
+pub async fn enqueue_hunyuan_3d_2_1_image_to_3d_webhook<U: IntoUrl, V: IntoUrl>(
+  args: Hunyuan3d21Args<'_, U, V>
+) -> Result<WebhookResponse, FalErrorPlus> {
+  
+  let image_url = args.image_url.as_str().to_string();
+
+  let request = Hunyuan3DInput {
+    input_image_url: image_url,
+    textured_mesh: Some(true),
+    // TODO: Maybe expose these later
+    guidance_scale: None,
+    num_inference_steps: None,
+    octree_resolution: None,
+    seed: None,
+  };
+
+  let result = v21(request)
+      .with_api_key(&args.api_key.0)
+      .queue_webhook(args.webhook_url)
+      .await;
+
+  result.map_err(|err| classify_fal_error(err))
+}
+
+#[cfg(test)]
+mod tests {
+  use crate::creds::fal_api_key::FalApiKey;
+  use crate::requests::webhook::object::enqueue_hunyuan_3d_21_image_to_3d_webhook::{enqueue_hunyuan_3d_2_1_image_to_3d_webhook, Hunyuan3d21Args};
+  use errors::AnyhowResult;
+  use std::fs::read_to_string;
+
+  #[tokio::test]
+  #[ignore]
+  async fn test_hunyuan3d_21() -> AnyhowResult<()> {
+    let image_url = "https://cdn-2.fakeyou.com/media/p/a/c/7/j/pac7jgp2tkehm7j7sm4sky1fpnkrnbve/image_pac7jgp2tkehm7j7sm4sky1fpnkrnbve.png";
+
+    // XXX: Don't commit secrets!
+    let secret = read_to_string("/Users/bt/Artcraft/credentials/fal_api_key.txt")?;
+
+    let api_key = FalApiKey::from_str(&secret);
+
+    let args = Hunyuan3d21Args {
+      image_url: image_url,
+      api_key: &api_key,
+      webhook_url: "https://example.com/webhook",
+    };
+
+    let result = enqueue_hunyuan_3d_2_1_image_to_3d_webhook(args).await?;
+
+    Ok(())
+  }
+}

crates/lib/api_clients/fal_client/src/requests/webhook/object/enqueue_hunyuan_3d_2_image_to_3d_webhook.rs

@@ -5,21 +5,14 @@ use fal::endpoints::fal_ai::hunyuan3d::v2::{v2, Hunyuan3DInput};
 use fal::webhook::WebhookResponse;
 use reqwest::IntoUrl;
 
-pub struct Hunyuan2Args<'a, U: IntoUrl, V: IntoUrl> {
+pub struct Hunyuan3d2Args<'a, U: IntoUrl, V: IntoUrl> {
   pub image_url: U,
   pub webhook_url: V,
   pub api_key: &'a FalApiKey,
 }
 
-#[derive(Copy, Clone, Debug)]
-pub enum Kling16Duration {
-  Default,
-  FiveSeconds,
-  TenSeconds,
-}
-
-pub async fn enqueue_hunyuan2_image_to_3d_webhook<U: IntoUrl, V: IntoUrl>(
-  args: Hunyuan2Args<'_, U, V>
+pub async fn enqueue_hunyuan_3d_2_image_to_3d_webhook<U: IntoUrl, V: IntoUrl>(
+  args: Hunyuan3d2Args<'_, U, V>
 ) -> Result<WebhookResponse, FalErrorPlus> {
   
   let image_url = args.image_url.as_str().to_string();

crates/lib/api_clients/fal_client/src/requests/webhook/object/mod.rs

@@ -1 +1,2 @@
-pub mod enqueue_hunyuan2_image_to_3d_webhook;
+pub mod enqueue_hunyuan_3d_2_image_to_3d_webhook;
+pub mod enqueue_hunyuan_3d_21_image_to_3d_webhook;

crates/lib/api_clients/fal_client/src/requests/webhook/video/enqueue_kling_16_pro_image_to_video_webhook.rs

@@ -5,12 +5,13 @@ use fal::endpoints::fal_ai::kling_video::v1_6::pro::image_to_video::{image_to_vi
 use fal::webhook::WebhookResponse;
 use reqwest::IntoUrl;
 
-pub struct Kling16Args<'a, U: IntoUrl, V: IntoUrl> {
+pub struct Kling16ProArgs<'a, U: IntoUrl, V: IntoUrl> {
   pub image_url: U,
   pub webhook_url: V,
   pub prompt: &'a str,
   pub api_key: &'a FalApiKey,
   pub duration: Kling16Duration,
+  pub aspect_ratio: Kling16ProAspectRatio,
 }
 
 #[derive(Copy, Clone, Debug)]
@@ -20,8 +21,15 @@ pub enum Kling16Duration {
   TenSeconds,
 }
 
-pub async fn enqueue_kling_16_image_to_video_webhook<U: IntoUrl, V: IntoUrl>(
-  args: Kling16Args<'_, U, V>
+#[derive(Copy, Clone, Debug)]
+pub enum Kling16ProAspectRatio {
+  Square, // 1:1
+  WideSixteenNine, // 16:9
+  TallNineSixteen, // 9:16
+}
+
+pub async fn enqueue_kling_16_pro_image_to_video_webhook<U: IntoUrl, V: IntoUrl>(
+  args: Kling16ProArgs<'_, U, V>
 ) -> Result<WebhookResponse, FalErrorPlus> {
   let duration = match args.duration {
     Kling16Duration::Default => None,
@@ -29,14 +37,21 @@ pub async fn enqueue_kling_16_image_to_video_webhook<U: IntoUrl, V: IntoUrl>(
     Kling16Duration::TenSeconds => Some("10".to_string()),
   };
   
+  let aspect_ratio = match args.aspect_ratio {
+    Kling16ProAspectRatio::Square => Some("1:1".to_string()),
+    Kling16ProAspectRatio::WideSixteenNine => Some("16:9".to_string()),
+    Kling16ProAspectRatio::TallNineSixteen => Some("9:16".to_string()),
+  };
+
   let image_url = args.image_url.as_str().to_string();
 
   let request = ProImageToVideoRequest {
     image_url,
     prompt: args.prompt.to_string(),
-    aspect_ratio: None,
-    cfg_scale: None,
+    aspect_ratio,
     duration,
+    // Maybe expose these later
+    cfg_scale: None,
     negative_prompt: None,
     tail_image_url: None,
   };

crates/lib/api_clients/fal_client/src/requests/webhook/video/enqueue_kling_21_master_image_to_video_webhook.rs

@@ -0,0 +1,98 @@
+use crate::creds::fal_api_key::FalApiKey;
+use crate::error::classify_fal_error::classify_fal_error;
+use crate::error::fal_error_plus::FalErrorPlus;
+use fal::endpoints::fal_ai::kling_video::v2_1::master::image_to_video::{image_to_video, MasterImageToVideoRequest};
+use fal::webhook::WebhookResponse;
+use reqwest::IntoUrl;
+
+pub struct Kling21MasterArgs<'a, U: IntoUrl, V: IntoUrl> {
+  pub image_url: U,
+  pub webhook_url: V,
+  pub prompt: &'a str,
+  pub api_key: &'a FalApiKey,
+  pub duration: Kling21MasterDuration,
+  pub aspect_ratio: Kling21MasterAspectRatio,
+}
+
+#[derive(Copy, Clone, Debug)]
+pub enum Kling21MasterDuration {
+  Default,
+  FiveSeconds,
+  TenSeconds,
+}
+
+#[derive(Copy, Clone, Debug)]
+pub enum Kling21MasterAspectRatio {
+  Square, // 1:1
+  WideSixteenNine, // 16:9
+  TallNineSixteen, // 9:16
+}
+
+pub async fn enqueue_kling_21_master_image_to_video_webhook<U: IntoUrl, V: IntoUrl>(
+  args: Kling21MasterArgs<'_, U, V>
+) -> Result<WebhookResponse, FalErrorPlus> {
+  let duration = match args.duration {
+    Kling21MasterDuration::Default => None,
+    Kling21MasterDuration::FiveSeconds => Some("5".to_string()), // Gross...
+    Kling21MasterDuration::TenSeconds => Some("10".to_string()),
+  };
+  
+  let aspect_ratio = match args.aspect_ratio {
+    Kling21MasterAspectRatio::Square => Some("1:1".to_string()),
+    Kling21MasterAspectRatio::WideSixteenNine => Some("16:9".to_string()),
+    Kling21MasterAspectRatio::TallNineSixteen => Some("9:16".to_string()),
+  };
+
+  let image_url = args.image_url.as_str().to_string();
+
+  let request = MasterImageToVideoRequest {
+    image_url,
+    prompt: args.prompt.to_string(),
+    aspect_ratio,
+    duration,
+    // Maybe expose these later
+    cfg_scale: None,
+    negative_prompt: None,
+    tail_image_url: None,
+  };
+
+  let result = image_to_video(request)
+      .with_api_key(&args.api_key.0)
+      .queue_webhook(args.webhook_url)
+      .await;
+
+  result.map_err(|err| classify_fal_error(err))
+}
+
+
+#[cfg(test)]
+mod tests {
+  use crate::creds::fal_api_key::FalApiKey;
+  use crate::requests::webhook::video::enqueue_kling_21_master_image_to_video_webhook::{enqueue_kling_21_master_image_to_video_webhook, Kling21MasterArgs, Kling21MasterAspectRatio, Kling21MasterDuration};
+  use errors::AnyhowResult;
+  use std::fs::read_to_string;
+
+  #[tokio::test]
+  #[ignore]
+  async fn test_kling21_master_video() -> AnyhowResult<()> {
+    let image_url = "https://cdn-2.fakeyou.com/media/3/4/h/f/s/34hfsmt8e38rvne6mwa4pwbxr6292sgy/image_34hfsmt8e38rvne6mwa4pwbxr6292sgy.png";
+
+    // XXX: Don't commit secrets!
+    let secret = read_to_string("/Users/bt/Artcraft/credentials/fal_api_key.txt")?;
+
+    let api_key = FalApiKey::from_str(&secret);
+
+    let args = Kling21MasterArgs {
+      image_url: image_url,
+      prompt: "a shot of the mountains, the camera rotates around to show the mountain range, the sun begins to set, and the moon becomes visible",
+      api_key: &api_key,
+      duration: Kling21MasterDuration::Default,
+      aspect_ratio: Kling21MasterAspectRatio::WideSixteenNine,
+      webhook_url: "https://example.com/webhook",
+    };
+
+    let result = enqueue_kling_21_master_image_to_video_webhook(args).await?;
+
+    Ok(())
+  }
+}

crates/lib/api_clients/fal_client/src/requests/webhook/video/enqueue_kling_21_pro_image_to_video_webhook.rs

@@ -0,0 +1,98 @@
+use crate::creds::fal_api_key::FalApiKey;
+use crate::error::classify_fal_error::classify_fal_error;
+use crate::error::fal_error_plus::FalErrorPlus;
+use fal::endpoints::fal_ai::kling_video::v2_1::pro::image_to_video::{image_to_video, ProImageToVideoRequest};
+use fal::webhook::WebhookResponse;
+use reqwest::IntoUrl;
+
+pub struct Kling21ProArgs<'a, U: IntoUrl, V: IntoUrl> {
+  pub image_url: U,
+  pub webhook_url: V,
+  pub prompt: &'a str,
+  pub api_key: &'a FalApiKey,
+  pub duration: Kling21ProDuration,
+  pub aspect_ratio: Kling21ProAspectRatio,
+}
+
+#[derive(Copy, Clone, Debug)]
+pub enum Kling21ProDuration {
+  Default,
+  FiveSeconds,
+  TenSeconds,
+}
+
+#[derive(Copy, Clone, Debug)]
+pub enum Kling21ProAspectRatio {
+  Square, // 1:1
+  WideSixteenNine, // 16:9
+  TallNineSixteen, // 9:16
+}
+
+pub async fn enqueue_kling_21_pro_image_to_video_webhook<U: IntoUrl, V: IntoUrl>(
+  args: Kling21ProArgs<'_, U, V>
+) -> Result<WebhookResponse, FalErrorPlus> {
+  let duration = match args.duration {
+    Kling21ProDuration::Default => None,
+    Kling21ProDuration::FiveSeconds => Some("5".to_string()), // Gross...
+    Kling21ProDuration::TenSeconds => Some("10".to_string()),
+  };
+  
+  let aspect_ratio = match args.aspect_ratio {
+    Kling21ProAspectRatio::Square => Some("1:1".to_string()),
+    Kling21ProAspectRatio::WideSixteenNine => Some("16:9".to_string()),
+    Kling21ProAspectRatio::TallNineSixteen => Some("9:16".to_string()),
+  };
+
+  let image_url = args.image_url.as_str().to_string();
+
+  let request = ProImageToVideoRequest {
+    image_url,
+    prompt: args.prompt.to_string(),
+    aspect_ratio,
+    duration,
+    // Maybe expose these later
+    cfg_scale: None,
+    negative_prompt: None,
+    tail_image_url: None,
+  };
+
+  let result = image_to_video(request)
+      .with_api_key(&args.api_key.0)
+      .queue_webhook(args.webhook_url)
+      .await;
+
+  result.map_err(|err| classify_fal_error(err))
+}
+
+
+#[cfg(test)]
+mod tests {
+  use crate::creds::fal_api_key::FalApiKey;
+  use crate::requests::webhook::video::enqueue_kling_21_pro_image_to_video_webhook::{enqueue_kling_21_pro_image_to_video_webhook, Kling21ProArgs, Kling21ProAspectRatio, Kling21ProDuration};
+  use errors::AnyhowResult;
+  use std::fs::read_to_string;
+
+  #[tokio::test]
+  #[ignore]
+  async fn test_kling21_pro_video() -> AnyhowResult<()> {
+    let image_url = "https://cdn-2.fakeyou.com/media/3/4/h/f/s/34hfsmt8e38rvne6mwa4pwbxr6292sgy/image_34hfsmt8e38rvne6mwa4pwbxr6292sgy.png";
+
+    // XXX: Don't commit secrets!
+    let secret = read_to_string("/Users/bt/Artcraft/credentials/fal_api_key.txt")?;
+
+    let api_key = FalApiKey::from_str(&secret);
+
+    let args = Kling21ProArgs {
+      image_url: image_url,
+      prompt: "a shot of the mountains, the camera rotates around to show the mountain range",
+      api_key: &api_key,
+      duration: Kling21ProDuration::Default,
+      aspect_ratio: Kling21ProAspectRatio::WideSixteenNine,
+      webhook_url: "https://example.com/webhook",
+    };
+
+    let result = enqueue_kling_21_pro_image_to_video_webhook(args).await?;
+
+    Ok(())
+  }
+}

crates/lib/api_clients/fal_client/src/requests/webhook/video/enqueue_seedance_1_lite_image_to_video_webhook.rs

@@ -0,0 +1,98 @@
+use crate::creds::fal_api_key::FalApiKey;
+use crate::error::classify_fal_error::classify_fal_error;
+use crate::error::fal_error_plus::FalErrorPlus;
+use fal::endpoints::fal_ai::bytedance::seedance::v1::lite::image_to_video::image_to_video;
+use fal::endpoints::fal_ai::bytedance::seedance::v1::lite::image_to_video::ImageToVideoRequest;
+use fal::webhook::WebhookResponse;
+use reqwest::IntoUrl;
+
+pub struct Seedance1LiteArgs<'a, U: IntoUrl, V: IntoUrl> {
+  pub image_url: U,
+  pub webhook_url: V,
+  pub prompt: &'a str,
+  pub api_key: &'a FalApiKey,
+  pub camera_fixed: bool,
+  pub duration: Seedance1LiteDuration,
+  pub resolution: Seedance1LiteResolution,
+  pub seed: Option<u32>,
+}
+
+#[derive(Copy, Clone, Debug)]
+pub enum Seedance1LiteDuration {
+  FiveSeconds,
+  TenSeconds,
+}
+
+#[derive(Copy, Clone, Debug)]
+pub enum Seedance1LiteResolution {
+  FourEightyP, // 480p
+  SevenTwentyP, // 720p
+}
+
+pub async fn enqueue_seedance_1_lite_image_to_video_webhook<U: IntoUrl, V: IntoUrl>(
+  args: Seedance1LiteArgs<'_, U, V>
+) -> Result<WebhookResponse, FalErrorPlus> {
+  let duration = match args.duration {
+    Seedance1LiteDuration::FiveSeconds => Some("5".to_string()),
+    Seedance1LiteDuration::TenSeconds => Some("10".to_string()),
+  };
+  
+  let resolution = match args.resolution {
+    Seedance1LiteResolution::FourEightyP => Some("480p".to_string()),
+    Seedance1LiteResolution::SevenTwentyP => Some("720p".to_string()),
+  };
+
+  let image_url = args.image_url.as_str().to_string();
+
+  let request = ImageToVideoRequest {
+    image_url,
+    prompt: args.prompt.to_string(),
+    duration,
+    resolution,
+    // TODO: Add these later
+    camera_fixed: None,
+    seed: -1,
+  };
+
+  let result = image_to_video(request)
+      .with_api_key(&args.api_key.0)
+      .queue_webhook(args.webhook_url)
+      .await;
+
+  result.map_err(|err| classify_fal_error(err))
+}
+
+
+#[cfg(test)]
+mod tests {
+  use crate::creds::fal_api_key::FalApiKey;
+  use crate::requests::webhook::video::enqueue_seedance_1_lite_image_to_video_webhook::{enqueue_seedance_1_lite_image_to_video_webhook, Seedance1LiteArgs, Seedance1LiteDuration, Seedance1LiteResolution};
+  use errors::AnyhowResult;
+  use std::fs::read_to_string;
+
+  #[tokio::test]
+  #[ignore]
+  async fn test_kling21_pro_video() -> AnyhowResult<()> {
+    let image_url = "https://cdn-2.fakeyou.com/media/3/4/h/f/s/34hfsmt8e38rvne6mwa4pwbxr6292sgy/image_34hfsmt8e38rvne6mwa4pwbxr6292sgy.png";
+
+    // XXX: Don't commit secrets!
+    let secret = read_to_string("/Users/bt/Artcraft/credentials/fal_api_key.txt")?;
+
+    let api_key = FalApiKey::from_str(&secret);
+
+    let args = Seedance1LiteArgs {
+      image_url: image_url,
+      prompt: "a shot of the mountains as the sun sets and reveals the moon and stars",
+      api_key: &api_key,
+      camera_fixed: false,
+      duration: Seedance1LiteDuration::FiveSeconds,
+      resolution: Seedance1LiteResolution::SevenTwentyP,
+      seed: None,
+      webhook_url: "https://example.com/webhook",
+    };
+
+    let result = enqueue_seedance_1_lite_image_to_video_webhook(args).await?;
+
+    Ok(())
+  }
+}

crates/lib/api_clients/fal_client/src/requests/webhook/video/enqueue_veo_2_image_to_video_webhook.rs

@@ -0,0 +1,102 @@
+use crate::creds::fal_api_key::FalApiKey;
+use crate::error::classify_fal_error::classify_fal_error;
+use crate::error::fal_error_plus::FalErrorPlus;
+use fal::endpoints::fal_ai::veo2::image_to_video::image_to_video;
+use fal::endpoints::fal_ai::veo2::image_to_video::ImageToVideoInput;
+use fal::webhook::WebhookResponse;
+use reqwest::IntoUrl;
+
+pub struct Veo2Args<'a, U: IntoUrl, V: IntoUrl> {
+  pub image_url: U,
+  pub webhook_url: V,
+  pub prompt: &'a str,
+  pub api_key: &'a FalApiKey,
+  pub duration: Veo2Duration,
+  pub aspect_ratio: Veo2AspectRatio,
+}
+
+#[derive(Copy, Clone, Debug)]
+pub enum Veo2Duration {
+  Default,
+  FiveSeconds,
+  SixSeconds,
+  SevenSeconds,
+  EightSeconds,
+}
+
+#[derive(Copy, Clone, Debug)]
+pub enum Veo2AspectRatio {
+  Auto,
+  AutoPreferPortrait,
+  WideSixteenNine, // 16:9
+  TallNineSixteen, // 9:16
+}
+
+pub async fn enqueue_veo_2_image_to_video_webhook<U: IntoUrl, V: IntoUrl>(
+  args: Veo2Args<'_, U, V>
+) -> Result<WebhookResponse, FalErrorPlus> {
+  let duration = match args.duration {
+    Veo2Duration::Default => None,
+    Veo2Duration::FiveSeconds => Some("5".to_string()),
+    Veo2Duration::SixSeconds => Some("6".to_string()),
+    Veo2Duration::SevenSeconds => Some("7".to_string()),
+    Veo2Duration::EightSeconds => Some("8".to_string()),
+  };
+  
+  let aspect_ratio = match args.aspect_ratio {
+    Veo2AspectRatio::Auto => Some("auto".to_string()),
+    Veo2AspectRatio::AutoPreferPortrait => Some("auto_prefer_portrait".to_string()),
+    Veo2AspectRatio::WideSixteenNine => Some("16:9".to_string()),
+    Veo2AspectRatio::TallNineSixteen => Some("9:16".to_string()),
+  };
+
+  let image_url = args.image_url.as_str().to_string();
+
+  let request = ImageToVideoInput {
+    image_url,
+    prompt: args.prompt.to_string(),
+    aspect_ratio,
+    duration,
+    // Maybe expose these later
+  };
+
+  let result = image_to_video(request)
+      .with_api_key(&args.api_key.0)
+      .queue_webhook(args.webhook_url)
+      .await;
+
+  result.map_err(|err| classify_fal_error(err))
+}
+
+
+#[cfg(test)]
+mod tests {
+  use crate::creds::fal_api_key::FalApiKey;
+  use crate::requests::webhook::video::enqueue_veo_2_image_to_video_webhook::{enqueue_veo_2_image_to_video_webhook, Veo2Args, Veo2AspectRatio, Veo2Duration};
+  use errors::AnyhowResult;
+  use std::fs::read_to_string;
+
+  #[tokio::test]
+  #[ignore]
+  async fn test_kling21_pro_video() -> AnyhowResult<()> {
+    let image_url = "https://cdn-2.fakeyou.com/media/3/4/h/f/s/34hfsmt8e38rvne6mwa4pwbxr6292sgy/image_34hfsmt8e38rvne6mwa4pwbxr6292sgy.png";
+
+    // XXX: Don't commit secrets!
+    let secret = read_to_string("/Users/bt/Artcraft/credentials/fal_api_key.txt")?;
+
+    let api_key = FalApiKey::from_str(&secret);
+
+    let args = Veo2Args {
+      image_url: image_url,
+      prompt: "a shot of the mountains as the sun sets and reveals the moon and stars",
+      api_key: &api_key,
+      duration: Veo2Duration::Default,
+      aspect_ratio: Veo2AspectRatio::WideSixteenNine,
+      webhook_url: "https://example.com/webhook",
+    };
+
+    let result = enqueue_veo_2_image_to_video_webhook(args).await?;
+
+    Ok(())
+  }
+}

crates/lib/api_clients/fal_client/src/requests/webhook/video/mod.rs

@@ -1 +1,5 @@
-pub mod enqueue_kling_16_image_to_video_webhook;
+pub mod enqueue_kling_16_pro_image_to_video_webhook;
+pub mod enqueue_kling_21_master_image_to_video_webhook;
+pub mod enqueue_kling_21_pro_image_to_video_webhook;
+pub mod enqueue_seedance_1_lite_image_to_video_webhook;
+pub mod enqueue_veo_2_image_to_video_webhook;

crates/lib/api_clients/storyteller_client/src/generate/image/generate_flux_pro_11_ultra_text_to_image.rs

@@ -0,0 +1,68 @@
+use crate::credentials::storyteller_credential_set::StorytellerCredentialSet;
+use crate::error::api_error::ApiError;
+use crate::error::client_error::ClientError;
+use crate::error::storyteller_error::StorytellerError;
+use crate::utils::api_host::ApiHost;
+use crate::utils::constants::{APPLICATION_JSON, USER_AGENT};
+use crate::utils::filter_bad_response::filter_bad_response;
+use artcraft_api_defs::generate::image::generate_flux_pro_11_ultra_text_to_image::{GenerateFluxPro11UltraTextToImageRequest, GenerateFluxPro11UltraTextToImageResponse, GENERATE_FLUX_PRO_11_ULTRA_TEXT_TO_IMAGE_PATH};
+use log::{debug, info};
+use reqwest::Client;
+
+pub async fn generate_flux_pro_11_ultra_text_to_image(
+  api_host: &ApiHost,
+  maybe_creds: Option<&StorytellerCredentialSet>,
+  request: GenerateFluxPro11UltraTextToImageRequest,
+) -> Result<GenerateFluxPro11UltraTextToImageResponse, StorytellerError> {
+
+  let url = get_route(api_host);
+
+  info!("Requesting {:?}", &url);
+
+  let client = Client::builder()
+      .gzip(true)
+      .build()
+      .map_err(|err| StorytellerError::Client(ClientError::from(err)))?;
+
+  let mut request_builder = client.post(url)
+      .header("User-Agent", USER_AGENT)
+      .header("Accept", APPLICATION_JSON)
+      .header("Content-Type", APPLICATION_JSON);
+
+  if let Some(creds) = maybe_creds {
+    if let Some(header) = &creds.maybe_as_cookie_header() {
+      request_builder = request_builder.header("Cookie", header);
+    }
+  }
+  
+  let request_body = serde_json::to_string(&request)
+      .map_err(|err| StorytellerError::Client(ClientError::from(err)))?;
+
+  debug!("Request body: {:?}", request_body);
+  
+  let response = request_builder
+      .body(request_body)
+      .send()
+      .await
+      .map_err(|err| StorytellerError::Api(ApiError::from(err)))?;
+
+  let response = filter_bad_response(response)
+      .await
+      .map_err(|err| StorytellerError::Api(ApiError::from(err)))?;
+  
+  let response_body = &response.text()
+      .await
+      .map_err(|err| StorytellerError::Api(ApiError::from(err)))?;
+
+  debug!("Response body: {:?}", response_body);
+  
+  let response = serde_json::from_str(&response_body)
+      .map_err(|err| StorytellerError::Api(ApiError::from(err)))?;
+
+  Ok(response)
+}
+
+fn get_route(api_host: &ApiHost) -> String {
+  let api_hostname = api_host.to_api_hostname();
+  format!("https://{}{}", api_hostname, GENERATE_FLUX_PRO_11_ULTRA_TEXT_TO_IMAGE_PATH)
+}

crates/lib/api_clients/storyteller_client/src/generate/image/mod.rs

@@ -0,0 +1 @@
+pub mod generate_flux_pro_11_ultra_text_to_image;

crates/lib/api_clients/storyteller_client/src/generate/mod.rs

@@ -1 +1,3 @@
-pub mod object;
+pub mod image;
+pub mod object;
+pub mod video;

crates/lib/api_clients/storyteller_client/src/generate/object/generate_hunyuan2_image_to_3d.rs

@@ -9,7 +9,6 @@ use artcraft_api_defs::generate::object::generate_hunyuan_2_image_to_3d::{Genera
 use log::{debug, info};
 use reqwest::Client;
 
-/// Upload an image media file from a file.
 pub async fn generate_hunyuan2_image_to_3d(
   api_host: &ApiHost,
   maybe_creds: Option<&StorytellerCredentialSet>,

crates/lib/api_clients/storyteller_client/src/generate/video/generate_kling_16_pro_image_to_video.rs

@@ -0,0 +1,68 @@
+use crate::credentials::storyteller_credential_set::StorytellerCredentialSet;
+use crate::error::api_error::ApiError;
+use crate::error::client_error::ClientError;
+use crate::error::storyteller_error::StorytellerError;
+use crate::utils::api_host::ApiHost;
+use crate::utils::constants::{APPLICATION_JSON, USER_AGENT};
+use crate::utils::filter_bad_response::filter_bad_response;
+use artcraft_api_defs::generate::video::generate_kling_1_6_pro_image_to_video::{GenerateKling16ProImageToVideoRequest, GenerateKling16ProImageToVideoResponse, GENERATE_KLING_1_6_PRO_IMAGE_TO_VIDEO_URL_PATH};
+use log::{debug, info};
+use reqwest::Client;
+
+pub async fn generate_kling_16_pro_image_to_video(
+  api_host: &ApiHost,
+  maybe_creds: Option<&StorytellerCredentialSet>,
+  request: GenerateKling16ProImageToVideoRequest,
+) -> Result<GenerateKling16ProImageToVideoResponse, StorytellerError> {
+
+  let url = get_route(api_host);
+
+  info!("Requesting {:?}", &url);
+
+  let client = Client::builder()
+      .gzip(true)
+      .build()
+      .map_err(|err| StorytellerError::Client(ClientError::from(err)))?;
+
+  let mut request_builder = client.post(url)
+      .header("User-Agent", USER_AGENT)
+      .header("Accept", APPLICATION_JSON)
+      .header("Content-Type", APPLICATION_JSON);
+
+  if let Some(creds) = maybe_creds {
+    if let Some(header) = &creds.maybe_as_cookie_header() {
+      request_builder = request_builder.header("Cookie", header);
+    }
+  }
+  
+  let request_body = serde_json::to_string(&request)
+      .map_err(|err| StorytellerError::Client(ClientError::from(err)))?;
+
+  debug!("Request body: {:?}", request_body);
+  
+  let response = request_builder
+      .body(request_body)
+      .send()
+      .await
+      .map_err(|err| StorytellerError::Api(ApiError::from(err)))?;
+
+  let response = filter_bad_response(response)
+      .await
+      .map_err(|err| StorytellerError::Api(ApiError::from(err)))?;
+  
+  let response_body = &response.text()
+      .await
+      .map_err(|err| StorytellerError::Api(ApiError::from(err)))?;
+
+  debug!("Response body: {:?}", response_body);
+  
+  let response = serde_json::from_str(&response_body)
+      .map_err(|err| StorytellerError::Api(ApiError::from(err)))?;
+
+  Ok(response)
+}
+
+fn get_route(api_host: &ApiHost) -> String {
+  let api_hostname = api_host.to_api_hostname();
+  format!("https://{}{}", api_hostname, GENERATE_KLING_1_6_PRO_IMAGE_TO_VIDEO_URL_PATH)
+}

crates/lib/api_clients/storyteller_client/src/generate/video/mod.rs

@@ -0,0 +1 @@
+pub mod generate_kling_16_pro_image_to_video;

crates/lib/api_clients/storyteller_client/src/media_files/get_media_file.rs

@@ -1,4 +1,5 @@
 use crate::error::api_error::ApiError;
+use crate::error::storyteller_error::StorytellerError;
 use crate::shared_response_types::media_file_cover_image_details::MediaFileCoverImageDetails;
 use crate::shared_response_types::media_links::MediaLinks;
 use crate::shared_response_types::simple_entity_stats::SimpleEntityStats;
@@ -23,16 +24,18 @@ use tokens::tokens::model_weights::ModelWeightToken;
 use tokens::tokens::prompts::PromptToken;
 
 /// Get details about a media file from our backend
-pub async fn get_media_file(api_host: &ApiHost, media_file_token: &MediaFileToken) -> Result<GetMediaFileSuccessResponse, ApiError> {
+pub async fn get_media_file(api_host: &ApiHost, media_file_token: &MediaFileToken) -> Result<GetMediaFileSuccessResponse, StorytellerError> {
   let url = get_media_file_token_route(api_host, media_file_token);
 
   debug!("Requesting {:?}", &url);
 
   let response = http_get_anonymous(url).await?;
   let response = filter_bad_response(response).await?;
-  let response_body = &response.text().await?;
+  let response_body = &response.text().await
+      .map_err(|err| StorytellerError::Api(ApiError::from(err)))?;
 
-  let media_file = serde_json::from_str(&response_body)?;
+  let media_file = serde_json::from_str(&response_body)
+      .map_err(|err| StorytellerError::Api(ApiError::from(err)))?;
 
   Ok(media_file)
 }

crates/lib/api_clients/storyteller_client/src/media_files/upload_image_media_file_from_file.rs

@@ -1,5 +1,7 @@
 use crate::credentials::storyteller_credential_set::StorytellerCredentialSet;
 use crate::error::api_error::ApiError;
+use crate::error::client_error::ClientError;
+use crate::error::storyteller_error::StorytellerError;
 use crate::shared_response_types::media_file_cover_image_details::MediaFileCoverImageDetails;
 use crate::shared_response_types::media_links::MediaLinks;
 use crate::shared_response_types::simple_entity_stats::SimpleEntityStats;
@@ -36,7 +38,7 @@ pub async fn upload_image_media_file_from_file<P: AsRef<Path>>(
   api_host: &ApiHost,
   maybe_creds: Option<&StorytellerCredentialSet>,
   path: P,
-) -> Result<UploadImageMediaFileSuccessResponse, ApiError> {
+) -> Result<UploadImageMediaFileSuccessResponse, StorytellerError> {
 
   let url = get_route(api_host);
 
@@ -46,12 +48,14 @@ pub async fn upload_image_media_file_from_file<P: AsRef<Path>>(
 
   let client = Client::builder()
       .gzip(true)
-      .build()?;
+      .build()
+      .map_err(|err| StorytellerError::Client(ClientError::from(err)))?;
 
   let form = Form::new()
       .text("uuid_idempotency_token", generate_random_uuid())
       .file("file", path)
-      .await?;
+      .await
+      .map_err(|err| StorytellerError::Client(ClientError::from(err)))?;
 
   let mut request_builder = client.post(url)
       .header("User-Agent", USER_AGENT)
@@ -66,12 +70,15 @@ pub async fn upload_image_media_file_from_file<P: AsRef<Path>>(
   let response = request_builder
       .multipart(form)
       .send()
-      .await?;
+      .await
+      .map_err(|err| StorytellerError::Api(ApiError::from(err)))?;
 
   let response = filter_bad_response(response).await?;
-  let response_body = &response.text().await?;
+  let response_body = &response.text().await
+      .map_err(|err| StorytellerError::Api(ApiError::from(err)))?;
 
-  let media_file = serde_json::from_str(&response_body)?;
+  let media_file = serde_json::from_str(&response_body)
+      .map_err(|err| StorytellerError::Api(ApiError::from(err)))?;
 
   Ok(media_file)
 }

crates/lib/api_clients/storyteller_client/src/recipes/upload_media_file_from_file.rs

@@ -54,7 +54,7 @@ pub async fn upload_media_file_from_file<P: AsRef<Path>>(
           success: result.success,
           media_file_token: result.media_file_token,
         }),
-        Err(err) => Err(StorytellerError::Api(err)),
+        Err(err) => Err(err),
       }
     }
     Some(_) => Err(StorytellerError::Client(ClientError::FileTypeNotHandled(path.as_ref().to_path_buf()))),

crates/lib/data/web_base64/Cargo.toml

@@ -0,0 +1,25 @@
+[package]
+name = "web_base64"
+edition = "2024"
+version = "0.0.1"
+publish = false
+
+[package.metadata.cargo-udeps.ignore]
+normal = ["workspace-build-acceleration"]
+
+[lib]
+name = "web_base64"
+path = "src/lib.rs"
+
+[dependencies]
+# Workspace hack (faster compile times)
+workspace-build-acceleration = { workspace =  true }
+
+# Internal
+# (None)
+
+# External
+base64 = { workspace = true }
+
+[dev-dependencies]
+# (None)

crates/lib/data/web_base64/src/lib.rs

@@ -0,0 +1,5 @@
+//! Base64 encoding and decoding library that handles data from the web.
+//! Most of the base64 we receive from the web is of a particular encoding 
+//! type, and we also have to juggle URL prefixes.
+
+pub mod web_base64_decode;

crates/lib/data/web_base64/src/web_base64_decode.rs

@@ -0,0 +1,14 @@
+use base64::prelude::BASE64_STANDARD;
+use base64::Engine;
+
+pub fn web_base64_decode(base64_string: &str) -> Result<Vec<u8>, base64::DecodeError> {
+  // Remove the data URL prefix if it exists
+  // eg: "data:image/png;base64,..." 
+  let base64_data = if base64_string.starts_with("data:") {
+    base64_string.split(',').nth(1).unwrap_or(base64_string)
+  } else {
+    base64_string
+  };
+
+  BASE64_STANDARD.decode(base64_data)
+}

crates/schema/public/api/artcraft_api_defs/src/generate/image/generate_flux_pro_11_ultra_text_to_image.rs

@@ -0,0 +1,20 @@
+use serde_derive::{Deserialize, Serialize};
+use tokens::tokens::generic_inference_jobs::InferenceJobToken;
+use utoipa::ToSchema;
+
+pub const GENERATE_FLUX_PRO_11_ULTRA_TEXT_TO_IMAGE_PATH: &str = "/v1/generate/image/flux_pro_1.1_ultra_text_to_image";
+
+#[derive(Serialize, Deserialize, ToSchema)]
+pub struct GenerateFluxPro11UltraTextToImageRequest {
+  /// Idempotency token to prevent duplicate requests.
+  pub uuid_idempotency_token: String,
+
+  /// Text prompt to generate the image from.
+  pub prompt: Option<String>,
+}
+
+#[derive(Serialize, Deserialize, ToSchema)]
+pub struct GenerateFluxPro11UltraTextToImageResponse {
+  pub success: bool,
+  pub inference_job_token: InferenceJobToken,
+}

crates/schema/public/api/artcraft_api_defs/src/generate/image/mod.rs

@@ -1 +1,2 @@
+pub mod generate_flux_pro_11_ultra_text_to_image;
 pub mod remove_image_background;

crates/schema/public/api/artcraft_api_defs/src/generate/video/generate_kling_1_6_pro_image_to_video.rs

@@ -3,10 +3,10 @@ use tokens::tokens::generic_inference_jobs::InferenceJobToken;
 use tokens::tokens::media_files::MediaFileToken;
 use utoipa::ToSchema;
 
-const GENERATE_KLING_1_6_IMAGE_TO_VIDEO_URL_PATH: &str = "/v1/generate/video/kling_16_image_to_video";
+pub const GENERATE_KLING_1_6_PRO_IMAGE_TO_VIDEO_URL_PATH: &str = "/v1/generate/video/kling_1.6_pro_image_to_video";
 
 #[derive(Serialize, Deserialize, ToSchema)]
-pub struct GenerateKling16ImageToVideoRequest {
+pub struct GenerateKling16ProImageToVideoRequest {
   /// Idempotency token to prevent duplicate requests.
   pub uuid_idempotency_token: String,
   
@@ -16,10 +16,23 @@ pub struct GenerateKling16ImageToVideoRequest {
   
   /// Optional text prompt.
   pub prompt: Option<String>,
+  
+  /// Optional: apsect ratio of the generated video.
+  pub aspect_ratio: Option<GenerateKling16ProAspectRatio>,
 }
 
 #[derive(Serialize, Deserialize, ToSchema)]
-pub struct GenerateKling16ImageToVideoResponse {
+pub enum GenerateKling16ProAspectRatio {
+  /// 16:9 aspect ratio
+  WideSixteenNine,
+  /// 9:16 aspect ratio
+  TallNineSixteen,
+  /// 1:1 aspect ratio
+  Square,
+}
+
+#[derive(Serialize, Deserialize, ToSchema)]
+pub struct GenerateKling16ProImageToVideoResponse {
   pub success: bool,
   pub inference_job_token: InferenceJobToken,
 }

crates/schema/public/api/artcraft_api_defs/src/generate/video/mod.rs

@@ -1 +1 @@
-pub mod generate_kling_1_6_image_to_video;
+pub mod generate_kling_1_6_pro_image_to_video;

crates/service/web/storyteller_web/src/http_server/endpoints/generate/image/generate_flux_pro_ultra_text_to_image_handler.rs

@@ -0,0 +1,175 @@
+use std::fmt;
+use std::sync::Arc;
+
+use crate::http_server::common_requests::media_file_token_path_info::MediaFileTokenPathInfo;
+use crate::http_server::common_responses::media::media_links::MediaLinks;
+use crate::http_server::deprecated_endpoints::engine::create_scene_handler::CreateSceneError;
+use crate::http_server::endpoints::media_files::helpers::get_media_domain::get_media_domain;
+use crate::http_server::endpoints::media_files::upload::upload_error::MediaFileUploadError;
+use crate::http_server::validations::validate_idempotency_token_format::validate_idempotency_token_format;
+use crate::http_server::web_utils::response_success_helpers::simple_json_success;
+use crate::state::server_state::ServerState;
+use crate::util::delete_role_disambiguation::{delete_role_disambiguation, DeleteRole};
+use actix_web::error::ResponseError;
+use actix_web::http::StatusCode;
+use actix_web::web::Json;
+use actix_web::web::Path;
+use actix_web::{web, HttpRequest, HttpResponse};
+use artcraft_api_defs::generate::image::generate_flux_pro_11_ultra_text_to_image::GenerateFluxPro11UltraTextToImageRequest;
+use artcraft_api_defs::generate::image::generate_flux_pro_11_ultra_text_to_image::GenerateFluxPro11UltraTextToImageResponse;
+use bucket_paths::legacy::typified_paths::public::media_files::bucket_file_path::MediaFileBucketPath;
+use enums::common::visibility::Visibility;
+use fal_client::requests::webhook::image::enqueue_flux_pro_11_ultra_text_to_image_webhook::enqueue_flux_pro_11_ultra_text_to_image_webhook;
+use fal_client::requests::webhook::image::enqueue_flux_pro_11_ultra_text_to_image_webhook::FluxPro11UltraArgs;
+use http_server_common::request::get_request_ip::get_request_ip;
+use http_server_common::response::serialize_as_json_error::serialize_as_json_error;
+use idempotency::uuid::generate_random_uuid;
+use log::{error, info, warn};
+use mysql_queries::queries::generic_inference::fal::insert_generic_inference_job_for_fal_queue::insert_generic_inference_job_for_fal_queue;
+use mysql_queries::queries::generic_inference::fal::insert_generic_inference_job_for_fal_queue::FalCategory;
+use mysql_queries::queries::generic_inference::fal::insert_generic_inference_job_for_fal_queue::InsertGenericInferenceForFalArgs;
+use mysql_queries::queries::idepotency_tokens::insert_idempotency_token::insert_idempotency_token;
+use mysql_queries::queries::media_files::get::get_media_file::{get_media_file, MediaFile};
+use tokens::tokens::media_files::MediaFileToken;
+use utoipa::ToSchema;
+
+// =============== Error Response ===============
+
+
+#[derive(Debug, Serialize, ToSchema)]
+pub enum GenerateFluxProUltraTextToImageError {
+  BadInput(String),
+  NotFound,
+  NotAuthorized,
+  ServerError,
+}
+
+impl ResponseError for GenerateFluxProUltraTextToImageError {
+  fn status_code(&self) -> StatusCode {
+    match *self {
+      GenerateFluxProUltraTextToImageError::BadInput(_) => StatusCode::BAD_REQUEST,
+      GenerateFluxProUltraTextToImageError::NotFound => StatusCode::NOT_FOUND,
+      GenerateFluxProUltraTextToImageError::NotAuthorized => StatusCode::UNAUTHORIZED,
+      GenerateFluxProUltraTextToImageError::ServerError => StatusCode::INTERNAL_SERVER_ERROR,
+    }
+  }
+
+  fn error_response(&self) -> HttpResponse {
+    serialize_as_json_error(self)
+  }
+}
+
+// NB: Not using derive_more::Display since Clion doesn't understand it.
+impl fmt::Display for GenerateFluxProUltraTextToImageError {
+  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    write!(f, "{:?}", self)
+  }
+}
+
+// =============== Handler ===============
+
+/// Flux pro ultra text to image
+#[utoipa::path(
+  post,
+  tag = "Generate Images",
+  path = "/v1/generate/image/flux_pro_1.1_ultra_text_to_image",
+  responses(
+    (status = 200, description = "Success", body = GenerateFluxProUltraTextToImageResponse),
+    (status = 400, description = "Bad input", body = GenerateFluxProUltraTextToImageError),
+    (status = 401, description = "Not authorized", body = GenerateFluxProUltraTextToImageError),
+    (status = 500, description = "Server error", body = GenerateFluxProUltraTextToImageError),
+  ),
+  params(
+    ("request" = GenerateFluxProUltraTextToImageRequest, description = "Payload for Request"),
+  )
+)]
+pub async fn generate_flux_pro_11_ultra_text_to_image_handler(
+  http_request: HttpRequest,
+  request: Json<GenerateFluxPro11UltraTextToImageRequest>,
+  server_state: web::Data<Arc<ServerState>>
+) -> Result<Json<GenerateFluxPro11UltraTextToImageResponse>, GenerateFluxProUltraTextToImageError> {
+  let maybe_user_session = server_state
+      .session_checker
+      .maybe_get_user_session(&http_request, &server_state.mysql_pool)
+      .await
+      .map_err(|e| {
+        warn!("Session checker error: {:?}", e);
+        GenerateFluxProUltraTextToImageError::ServerError
+      })?;
+
+  let maybe_avt_token = server_state
+      .avt_cookie_manager
+      .get_avt_token_from_request(&http_request);
+
+  // TODO: Limit usage for new accounts. Billing, free credits metering, etc.
+
+  //let user_session = match maybe_user_session {
+  //  Some(session) => session,
+  //  None => {
+  //    warn!("not logged in");
+  //    return Err(GenerateFluxProUltraTextToImageError::NotAuthorized);
+  //  }
+  //};
+
+  if let Err(reason) = validate_idempotency_token_format(&request.uuid_idempotency_token) {
+    return Err(GenerateFluxProUltraTextToImageError::BadInput(reason));
+  }
+
+  insert_idempotency_token(&request.uuid_idempotency_token, &server_state.mysql_pool)
+      .await
+      .map_err(|err| {
+        error!("Error inserting idempotency token: {:?}", err);
+        GenerateFluxProUltraTextToImageError::BadInput("invalid idempotency token".to_string())
+      })?;
+  const IS_MOD : bool = false;
+  
+  info!("Fal webhook URL: {}", server_state.fal.webhook_url);
+  
+  let args = FluxPro11UltraArgs {
+    prompt: request.prompt.as_deref().unwrap_or(""),
+    webhook_url: &server_state.fal.webhook_url,
+    api_key: &server_state.fal.api_key,
+  };
+
+  let fal_result = enqueue_flux_pro_11_ultra_text_to_image_webhook(args)
+      .await
+      .map_err(|err| {
+        warn!("Error calling enqueue_flux_pro_ultra_text_to_image_webhook: {:?}", err);
+        GenerateFluxProUltraTextToImageError::ServerError
+      })?;
+
+  let external_job_id = fal_result.request_id
+      .ok_or_else(|| {
+        warn!("Fal request_id is None");
+        GenerateFluxProUltraTextToImageError::ServerError
+      })?;
+  
+  info!("Fal request_id: {}", external_job_id);
+  
+  let ip_address = get_request_ip(&http_request);
+
+  let db_result = insert_generic_inference_job_for_fal_queue(InsertGenericInferenceForFalArgs {
+    uuid_idempotency_token: &request.uuid_idempotency_token,
+    maybe_external_third_party_id: &external_job_id,
+    fal_category: FalCategory::ImageGeneration,
+    maybe_inference_args: None,
+    maybe_creator_user_token: maybe_user_session.as_ref().map(|s| &s.user_token),
+    maybe_avt_token: maybe_avt_token.as_ref(),
+    creator_ip_address: &ip_address,
+    creator_set_visibility: Visibility::Public,
+    mysql_pool: &server_state.mysql_pool,
+  }).await;
+
+  let job_token = match db_result {
+    Ok(token) => token,
+    Err(err) => {
+      warn!("Error inserting generic inference job for FAL queue: {:?}", err);
+      return Err(GenerateFluxProUltraTextToImageError::ServerError);
+    }
+  };
+
+  Ok(Json(GenerateFluxPro11UltraTextToImageResponse {
+    success: true,
+    inference_job_token: job_token,
+  }))
+}

crates/service/web/storyteller_web/src/http_server/endpoints/generate/image/mod.rs

@@ -1 +1,2 @@
+pub mod generate_flux_pro_ultra_text_to_image_handler;
 pub mod remove_image_background_handler;

crates/service/web/storyteller_web/src/http_server/endpoints/generate/object/generate_hunyuan2_image_to_3d_handler.rs

@@ -19,8 +19,8 @@ use artcraft_api_defs::generate::object::generate_hunyuan_2_image_to_3d::Generat
 use artcraft_api_defs::generate::object::generate_hunyuan_2_image_to_3d::GenerateHunyuan2ImageTo3dResponse;
 use bucket_paths::legacy::typified_paths::public::media_files::bucket_file_path::MediaFileBucketPath;
 use enums::common::visibility::Visibility;
-use fal_client::requests::webhook::object::enqueue_hunyuan2_image_to_3d_webhook::enqueue_hunyuan2_image_to_3d_webhook;
-use fal_client::requests::webhook::object::enqueue_hunyuan2_image_to_3d_webhook::Hunyuan2Args;
+use fal_client::requests::webhook::object::enqueue_hunyuan_3d_2_image_to_3d_webhook::enqueue_hunyuan_3d_2_image_to_3d_webhook;
+use fal_client::requests::webhook::object::enqueue_hunyuan_3d_2_image_to_3d_webhook::Hunyuan3d2Args;
 use http_server_common::request::get_request_ip::get_request_ip;
 use http_server_common::response::serialize_as_json_error::serialize_as_json_error;
 use idempotency::uuid::generate_random_uuid;
@@ -167,13 +167,13 @@ pub async fn generate_hunyuan_2_image_to_3d_handler(
   
   info!("Fal webhook URL: {}", server_state.fal.webhook_url);
   
-  let args = Hunyuan2Args {
+  let args = Hunyuan3d2Args {
     image_url: media_links.cdn_url,
     webhook_url: &server_state.fal.webhook_url,
     api_key: &server_state.fal.api_key,
   };
 
-  let fal_result = enqueue_hunyuan2_image_to_3d_webhook(args)
+  let fal_result = enqueue_hunyuan_3d_2_image_to_3d_webhook(args)
       .await
       .map_err(|err| {
         warn!("Error calling enqueue_hunyuan2_image_to_3d_webhook: {:?}", err);

crates/service/web/storyteller_web/src/http_server/endpoints/generate/video/generate_kling_1_6_pro_video_handler.rs

@@ -15,13 +15,14 @@ use actix_web::http::StatusCode;
 use actix_web::web::Json;
 use actix_web::web::Path;
 use actix_web::{web, HttpRequest, HttpResponse};
-use artcraft_api_defs::generate::video::generate_kling_1_6_image_to_video::GenerateKling16ImageToVideoRequest;
-use artcraft_api_defs::generate::video::generate_kling_1_6_image_to_video::GenerateKling16ImageToVideoResponse;
+use artcraft_api_defs::generate::video::generate_kling_1_6_pro_image_to_video::GenerateKling16ProImageToVideoResponse;
+use artcraft_api_defs::generate::video::generate_kling_1_6_pro_image_to_video::{GenerateKling16ProAspectRatio, GenerateKling16ProImageToVideoRequest};
 use bucket_paths::legacy::typified_paths::public::media_files::bucket_file_path::MediaFileBucketPath;
 use enums::common::visibility::Visibility;
-use fal_client::requests::webhook::video::enqueue_kling_16_image_to_video_webhook::enqueue_kling_16_image_to_video_webhook;
-use fal_client::requests::webhook::video::enqueue_kling_16_image_to_video_webhook::Kling16Args;
-use fal_client::requests::webhook::video::enqueue_kling_16_image_to_video_webhook::Kling16Duration;
+use fal_client::requests::webhook::video::enqueue_kling_16_pro_image_to_video_webhook::enqueue_kling_16_pro_image_to_video_webhook;
+use fal_client::requests::webhook::video::enqueue_kling_16_pro_image_to_video_webhook::Kling16Duration;
+use fal_client::requests::webhook::video::enqueue_kling_16_pro_image_to_video_webhook::Kling16ProArgs;
+use fal_client::requests::webhook::video::enqueue_kling_16_pro_image_to_video_webhook::Kling16ProAspectRatio;
 use http_server_common::request::get_request_ip::get_request_ip;
 use http_server_common::response::serialize_as_json_error::serialize_as_json_error;
 use idempotency::uuid::generate_random_uuid;
@@ -37,6 +38,29 @@ use utoipa::ToSchema;
 // =============== Error Response ===============
 
 
+/*
+ TODO: Either on the Tauri client or as an API, make "generic" image / video / object endpoints. 
+  Take a reference image payload: 
+  
+    ReferenceImage {
+      media_token: MediaFileToken,
+      reference_type: ReferenceType
+    } 
+    
+    enum ReferenceType {
+      PrimaryReference,
+      CharacterReference,
+      LocationReference,
+      StyleReference,
+      ...
+      GenericReference,
+    }
+    
+    // **ORDER MATTERS**
+    reference_images: Vec<ReferenceImage>,
+
+*/
+
 #[derive(Debug, Serialize, ToSchema)]
 pub enum GenerateKling16VideoError {
   BadInput(String),
@@ -73,7 +97,7 @@ impl fmt::Display for GenerateKling16VideoError {
 #[utoipa::path(
   post,
   tag = "Generate Videos",
-  path = "/v1/generate/video/kling_16_image_to_video",
+  path = "/v1/generate/video/kling_1.6_pro_image_to_video",
   responses(
     (status = 200, description = "Success", body = RemoveImageBackgroundResponse),
     (status = 400, description = "Bad input", body = RemoveImageBackgroundError),
@@ -84,11 +108,11 @@ impl fmt::Display for GenerateKling16VideoError {
     ("request" = RemoveImageBackgroundRequest, description = "Payload for Request"),
   )
 )]
-pub async fn generate_kling_1_6_video_handler(
+pub async fn generate_kling_1_6_pro_video_handler(
   http_request: HttpRequest,
-  request: Json<GenerateKling16ImageToVideoRequest>,
+  request: Json<GenerateKling16ProImageToVideoRequest>,
   server_state: web::Data<Arc<ServerState>>
-) -> Result<Json<GenerateKling16ImageToVideoResponse>, GenerateKling16VideoError> {
+) -> Result<Json<GenerateKling16ProImageToVideoResponse>, GenerateKling16VideoError> {
   let maybe_user_session = server_state
       .session_checker
       .maybe_get_user_session(&http_request, &server_state.mysql_pool)
@@ -173,15 +197,23 @@ pub async fn generate_kling_1_6_video_handler(
       .map(|prompt| prompt.trim())
       .unwrap_or_else(|| "");
   
-  let args = Kling16Args {
+  let aspect_ratio = match &request.aspect_ratio {
+    Some(GenerateKling16ProAspectRatio::Square) => Kling16ProAspectRatio::Square,
+    Some(GenerateKling16ProAspectRatio::WideSixteenNine) => Kling16ProAspectRatio::WideSixteenNine,
+    Some(GenerateKling16ProAspectRatio::TallNineSixteen) => Kling16ProAspectRatio::TallNineSixteen,
+    None => Kling16ProAspectRatio::WideSixteenNine, // Default to 16:9
+  };
+  
+  let args = Kling16ProArgs {
     image_url: media_links.cdn_url,
     webhook_url: &server_state.fal.webhook_url,
     duration: Kling16Duration::Default,
     prompt: prompt,
+    aspect_ratio: aspect_ratio,
     api_key: &server_state.fal.api_key,
   };
 
-  let fal_result = enqueue_kling_16_image_to_video_webhook(args)
+  let fal_result = enqueue_kling_16_pro_image_to_video_webhook(args)
       .await
       .map_err(|err| {
         warn!("Error calling remove_background_rembg_webhook: {:?}", err);
@@ -218,7 +250,7 @@ pub async fn generate_kling_1_6_video_handler(
     }
   };
 
-  Ok(Json(GenerateKling16ImageToVideoResponse {
+  Ok(Json(GenerateKling16ProImageToVideoResponse {
     success: true,
     inference_job_token: job_token,
   }))

crates/service/web/storyteller_web/src/http_server/endpoints/generate/video/mod.rs

@@ -1 +1 @@
-pub mod generate_kling_1_6_video_handler;
+pub mod generate_kling_1_6_pro_video_handler;

crates/service/web/storyteller_web/src/http_server/routes/add_generate_routes.rs

@@ -1,6 +1,7 @@
+use crate::http_server::endpoints::generate::image::generate_flux_pro_ultra_text_to_image_handler::generate_flux_pro_11_ultra_text_to_image_handler;
 use crate::http_server::endpoints::generate::image::remove_image_background_handler::remove_image_background_handler;
 use crate::http_server::endpoints::generate::object::generate_hunyuan2_image_to_3d_handler::generate_hunyuan_2_image_to_3d_handler;
-use crate::http_server::endpoints::generate::video::generate_kling_1_6_video_handler::generate_kling_1_6_video_handler;
+use crate::http_server::endpoints::generate::video::generate_kling_1_6_pro_video_handler::generate_kling_1_6_pro_video_handler;
 use actix_http::body::MessageBody;
 use actix_service::ServiceFactory;
 use actix_web::dev::{ServiceRequest, ServiceResponse};
@@ -19,14 +20,18 @@ where
 {
   app.service(web::scope("/v1/generate")
       .service(web::scope("/image")
+        .service(web::resource("/flux_pro_1.1_ultra_text_to_image")
+            .route(web::post().to(generate_flux_pro_11_ultra_text_to_image_handler))
+            .route(web::head().to(|| HttpResponse::Ok()))
+        )
         .service(web::resource("/remove_background")
             .route(web::post().to(remove_image_background_handler))
             .route(web::head().to(|| HttpResponse::Ok()))
         )
       )
       .service(web::scope("/video")
-          .service(web::resource("/kling_16_image_to_video")
-              .route(web::post().to(generate_kling_1_6_video_handler))
+          .service(web::resource("/kling_1.6_pro_image_to_video")
+              .route(web::post().to(generate_kling_1_6_pro_video_handler))
               .route(web::head().to(|| HttpResponse::Ok()))
           )
       )

crates/vendor/fal-rs/Cargo.toml

@@ -86,6 +86,7 @@ endpoints_fal-ai_auto-caption = []
 endpoints_fal-ai_ben = []
 endpoints_fal-ai_birefnet = []
 endpoints_fal-ai_bria = []
+endpoints_fal-ai_bytedance = []
 endpoints_fal-ai_cat-vton = []
 endpoints_fal-ai_ccsr = []
 endpoints_fal-ai_clarity-upscaler = []

crates/vendor/fal-rs/src/endpoints/fal_ai/bytedance/mod.rs

@@ -0,0 +1,14 @@
+#[cfg(any(
+  feature = "endpoints",
+  feature = "endpoints_fal-ai",
+  feature = "endpoints_fal-ai_bytedance"
+))]
+#[cfg_attr(
+  docsrs,
+  doc(cfg(any(
+    feature = "endpoints",
+    feature = "endpoints_fal-ai",
+    feature = "endpoints_fal-ai_bytedance"
+  )))
+)]
+pub mod seedance;

crates/vendor/fal-rs/src/endpoints/fal_ai/bytedance/seedance/mod.rs

@@ -0,0 +1,14 @@
+#[cfg(any(
+  feature = "endpoints",
+  feature = "endpoints_fal-ai",
+  feature = "endpoints_fal-ai_bytedance"
+))]
+#[cfg_attr(
+  docsrs,
+  doc(cfg(any(
+    feature = "endpoints",
+    feature = "endpoints_fal-ai",
+    feature = "endpoints_fal-ai_bytedance"
+  )))
+)]
+pub mod v1;

crates/vendor/fal-rs/src/endpoints/fal_ai/bytedance/seedance/v1/lite/image_to_video/mod.rs

@@ -0,0 +1,69 @@
+#[allow(unused_imports)]
+use crate::prelude::*;
+#[allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[allow(unused_imports)]
+use std::collections::HashMap;
+
+#[derive(Debug, Serialize, Deserialize, Default)]
+pub struct File {
+  /// The mime type of the file.
+  /// "image/png"
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub content_type: Option<String>,
+  /// File data
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub file_data: Option<String>,
+  /// The name of the file. It will be auto-generated if not provided.
+  /// "z9RV14K95DvU.png"
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub file_name: Option<String>,
+  /// The size of the file in bytes.
+  /// 4404019
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub file_size: Option<i64>,
+  /// The URL where the file can be downloaded from.
+  pub url: String,
+}
+
+#[derive(Debug, Serialize, Deserialize, Default)]
+pub struct HTTPValidationError {
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub detail: Option<Vec<Option<ValidationError>>>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct I2VOutput {
+  /// The generated video
+  /// {"url":"https://v2.fal.media/files/36087878b0c1435bb75c19b64b7db178_output.mp4"}
+  pub video: File,
+}
+
+#[derive(Debug, Serialize, Deserialize, Default)]
+pub struct ImageToVideoRequest {
+  /// The resolution of the generated video frame
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub resolution: Option<String>,
+  /// The duration of the generated video in seconds
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub duration: Option<String>,
+  pub image_url: String,
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub camera_fixed: Option<bool>,
+  pub prompt: String,
+  pub seed: i32,
+}
+
+#[derive(Debug, Serialize, Deserialize, Default)]
+pub struct ValidationError {
+  pub loc: Vec<serde_json::Value>,
+  pub msg: String,
+  #[serde(rename = "type")]
+  pub ty: String,
+}
+
+pub fn image_to_video(
+  params: ImageToVideoRequest,
+) -> FalRequest<ImageToVideoRequest, I2VOutput> {
+  FalRequest::new("fal-ai/bytedance/seedance/v1/lite/image-to-video", params)
+}

crates/vendor/fal-rs/src/endpoints/fal_ai/bytedance/seedance/v1/lite/mod.rs

@@ -0,0 +1,14 @@
+#[cfg(any(
+  feature = "endpoints",
+  feature = "endpoints_fal-ai",
+  feature = "endpoints_fal-ai_bytedance"
+))]
+#[cfg_attr(
+  docsrs,
+  doc(cfg(any(
+    feature = "endpoints",
+    feature = "endpoints_fal-ai",
+    feature = "endpoints_fal-ai_bytedance"
+  )))
+)]
+pub mod image_to_video;

crates/vendor/fal-rs/src/endpoints/fal_ai/bytedance/seedance/v1/mod.rs

@@ -0,0 +1,14 @@
+#[cfg(any(
+  feature = "endpoints",
+  feature = "endpoints_fal-ai",
+  feature = "endpoints_fal-ai_bytedance"
+))]
+#[cfg_attr(
+  docsrs,
+  doc(cfg(any(
+    feature = "endpoints",
+    feature = "endpoints_fal-ai",
+    feature = "endpoints_fal-ai_bytedance"
+  )))
+)]
+pub mod lite;

crates/vendor/fal-rs/src/endpoints/fal_ai/hunyuan3d/mod.rs

@@ -12,3 +12,17 @@
     )))
 )]
 pub mod v2;
+#[cfg(any(
+    feature = "endpoints",
+    feature = "endpoints_fal-ai",
+    feature = "endpoints_fal-ai_hunyuan3d"
+))]
+#[cfg_attr(
+    docsrs,
+    doc(cfg(any(
+        feature = "endpoints",
+        feature = "endpoints_fal-ai",
+        feature = "endpoints_fal-ai_hunyuan3d"
+    )))
+)]
+pub mod v21;

crates/vendor/fal-rs/src/endpoints/fal_ai/hunyuan3d/v21/mod.rs

@@ -0,0 +1,64 @@
+use crate::prelude::FalRequest;
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Serialize, Deserialize, Default)]
+pub struct Hunyuan3DInput {
+  /// Guidance scale for the model.
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub guidance_scale: Option<f64>,
+  /// URL of image to use while generating the 3D model.
+  /// "https://storage.googleapis.com/falserverless/model_tests/video_models/robot.png"
+  pub input_image_url: String,
+  /// Number of inference steps to perform.
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub num_inference_steps: Option<i64>,
+  /// Octree resolution for the model.
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub octree_resolution: Option<i64>,
+  /// The same seed and the same prompt given to the same version of the model
+  /// will output the same image every time.
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub seed: Option<i64>,
+  /// If set true, textured mesh will be generated and the price charged would be 3 times that of white mesh.
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub textured_mesh: Option<bool>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct ObjectOutput {
+  /// Generated 3D object file.
+  /// {"content_type":"application/octet-stream","file_name":"white_mesh.glb","file_size":720696,"url":"https://v3.fal.media/files/lion/WqIhtKPaSoeBtC30qzIGG_white_mesh.glb"}
+  pub model_mesh: File,
+  /// Seed value used for generation.
+  pub seed: i64,
+}
+
+#[derive(Debug, Serialize, Deserialize, Default)]
+pub struct File {
+  /// The mime type of the file.
+  /// "image/png"
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub content_type: Option<String>,
+  /// File data
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub file_data: Option<String>,
+  /// The name of the file. It will be auto-generated if not provided.
+  /// "z9RV14K95DvU.png"
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub file_name: Option<String>,
+  /// The size of the file in bytes.
+  /// 4404019
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub file_size: Option<i64>,
+  /// The URL where the file can be downloaded from.
+  pub url: String,
+}
+
+/// Hunyuan3D
+///
+/// Category: image-to-3d
+/// Machine Type: H100
+/// License Type: commercial
+pub fn v21(params: Hunyuan3DInput) -> FalRequest<Hunyuan3DInput, ObjectOutput> {
+  FalRequest::new("fal-ai/hunyuan3d-v21", params)
+}

crates/vendor/fal-rs/src/endpoints/fal_ai/kling_video/mod.rs

@@ -40,3 +40,17 @@ pub mod v1_5;
     )))
 )]
 pub mod v1_6;
+#[cfg(any(
+    feature = "endpoints",
+    feature = "endpoints_fal-ai",
+    feature = "endpoints_fal-ai_kling-video"
+))]
+#[cfg_attr(
+    docsrs,
+    doc(cfg(any(
+        feature = "endpoints",
+        feature = "endpoints_fal-ai",
+        feature = "endpoints_fal-ai_kling-video"
+    )))
+)]
+pub mod v2_1;

crates/vendor/fal-rs/src/endpoints/fal_ai/kling_video/v2_1/master/image_to_video/mod.rs

@@ -0,0 +1,241 @@
+#[allow(unused_imports)]
+use crate::prelude::*;
+#[allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[allow(unused_imports)]
+use std::collections::HashMap;
+
+// #[derive(Debug, Serialize, Deserialize, Default)]
+// pub struct CameraControl {
+//   /// The type of camera movement
+//   /// "horizontal"
+//   pub movement_type: String,
+//   /// The value of the camera movement
+//   /// 10
+//   pub movement_value: i64,
+// }
+
+// #[derive(Debug, Serialize, Deserialize, Default)]
+// pub struct DynamicMask {
+//   /// URL of the image for Dynamic Brush Application Area (Mask image created by users using the motion brush)
+//   /// "https://h2.inkwai.com/bs2/upload-ylab-stunt/ai_portal/1732888130/WU8spl23dA/dynamic_mask_1.png"
+//   pub mask_url: String,
+//   /// List of trajectories
+//   /// [{"x":279,"y":219},{"x":417,"y":65}]
+//   #[serde(skip_serializing_if = "Option::is_none")]
+//   pub trajectories: Option<Vec<Option<Trajectory>>>,
+// }
+
+#[derive(Debug, Serialize, Deserialize, Default)]
+pub struct File {
+  /// The mime type of the file.
+  /// "image/png"
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub content_type: Option<String>,
+  /// File data
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub file_data: Option<String>,
+  /// The name of the file. It will be auto-generated if not provided.
+  /// "z9RV14K95DvU.png"
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub file_name: Option<String>,
+  /// The size of the file in bytes.
+  /// 4404019
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub file_size: Option<i64>,
+  /// The URL where the file can be downloaded from.
+  pub url: String,
+}
+
+#[derive(Debug, Serialize, Deserialize, Default)]
+pub struct HTTPValidationError {
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub detail: Option<Vec<Option<ValidationError>>>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct I2VOutput {
+  /// The generated video
+  /// {"url":"https://v2.fal.media/files/36087878b0c1435bb75c19b64b7db178_output.mp4"}
+  pub video: File,
+}
+
+#[derive(Debug, Serialize, Deserialize, Default)]
+pub struct ImageToVideoRequest {
+  /// The aspect ratio of the generated video frame
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub aspect_ratio: Option<String>,
+  /// The CFG (Classifier Free Guidance) scale is a measure of how close you want
+  /// the model to stick to your prompt.
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub cfg_scale: Option<f64>,
+  /// The duration of the generated video in seconds
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub duration: Option<String>,
+  pub image_url: String,
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub negative_prompt: Option<String>,
+  pub prompt: String,
+}
+
+// #[derive(Debug, Serialize, Deserialize, Default)]
+// pub struct KlingV1I2VOutput {
+//   /// The generated video
+//   /// {"url":"https://v3.fal.media/files/kangaroo/VUmAU3JvzS7mxwdgSU9zj_output.mp4"}
+//   pub video: File,
+// }
+
+#[derive(Debug, Serialize, Deserialize, Default)]
+pub struct MasterImageToVideoRequest {
+  /// The aspect ratio of the generated video frame
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub aspect_ratio: Option<String>,
+  /// The CFG (Classifier Free Guidance) scale is a measure of how close you want
+  /// the model to stick to your prompt.
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub cfg_scale: Option<f64>,
+  /// The duration of the generated video in seconds
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub duration: Option<String>,
+  pub image_url: String,
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub negative_prompt: Option<String>,
+  pub prompt: String,
+  /// URL of the image to be used for the end of the video
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub tail_image_url: Option<String>,
+}
+
+// #[derive(Debug, Serialize, Deserialize, Default)]
+// pub struct T2VOutput {
+//   /// The generated video
+//   /// {"url":"https://v2.fal.media/files/fb33a862b94d4d7195e610e4cbc5d392_output.mp4"}
+//   pub video: File,
+// }
+// 
+// #[derive(Debug, Serialize, Deserialize, Default)]
+// pub struct TextToVideoRequest {
+//   /// The aspect ratio of the generated video frame
+//   #[serde(skip_serializing_if = "Option::is_none")]
+//   pub aspect_ratio: Option<String>,
+//   /// The CFG (Classifier Free Guidance) scale is a measure of how close you want
+//   /// the model to stick to your prompt.
+//   #[serde(skip_serializing_if = "Option::is_none")]
+//   pub cfg_scale: Option<f64>,
+//   /// The duration of the generated video in seconds
+//   #[serde(skip_serializing_if = "Option::is_none")]
+//   pub duration: Option<String>,
+//   #[serde(skip_serializing_if = "Option::is_none")]
+//   pub negative_prompt: Option<String>,
+//   pub prompt: String,
+// }
+// 
+// #[derive(Debug, Serialize, Deserialize, Default)]
+// pub struct Trajectory {
+//   /// X coordinate of the motion trajectory
+//   /// 279
+//   pub x: i64,
+//   /// Y coordinate of the motion trajectory
+//   /// 219
+//   pub y: i64,
+// }
+// 
+// #[derive(Debug, Serialize, Deserialize, Default)]
+// pub struct V1ImageToVideoRequest {
+//   /// The aspect ratio of the generated video frame
+//   #[serde(skip_serializing_if = "Option::is_none")]
+//   pub aspect_ratio: Option<String>,
+//   /// The CFG (Classifier Free Guidance) scale is a measure of how close you want
+//   /// the model to stick to your prompt.
+//   #[serde(skip_serializing_if = "Option::is_none")]
+//   pub cfg_scale: Option<f64>,
+//   /// The duration of the generated video in seconds
+//   #[serde(skip_serializing_if = "Option::is_none")]
+//   pub duration: Option<String>,
+//   /// List of dynamic masks
+//   #[serde(skip_serializing_if = "Option::is_none")]
+//   pub dynamic_masks: Option<Vec<Option<DynamicMask>>>,
+//   /// URL of the image to be used for the video
+//   /// "https://h2.inkwai.com/bs2/upload-ylab-stunt/se/ai_portal_queue_mmu_image_upscale_aiweb/3214b798-e1b4-4b00-b7af-72b5b0417420_raw_image_0.jpg"
+//   pub image_url: String,
+//   #[serde(skip_serializing_if = "Option::is_none")]
+//   pub negative_prompt: Option<String>,
+//   /// The prompt for the video
+//   /// "The astronaut stood up and walked away"
+//   pub prompt: String,
+//   /// URL of the image for Static Brush Application Area (Mask image created by users using the motion brush)
+//   /// "https://h2.inkwai.com/bs2/upload-ylab-stunt/ai_portal/1732888177/cOLNrShrSO/static_mask.png"
+//   #[serde(skip_serializing_if = "Option::is_none")]
+//   pub static_mask_url: Option<String>,
+//   /// URL of the image to be used for the end of the video
+//   #[serde(skip_serializing_if = "Option::is_none")]
+//   pub tail_image_url: Option<String>,
+// }
+// 
+// #[derive(Debug, Serialize, Deserialize, Default)]
+// pub struct V1TextToVideoRequest {
+//   /// Advanced Camera control parameters
+//   #[serde(skip_serializing_if = "Option::is_none")]
+//   pub advanced_camera_control: Option<Option<CameraControl>>,
+//   /// The aspect ratio of the generated video frame
+//   #[serde(skip_serializing_if = "Option::is_none")]
+//   pub aspect_ratio: Option<String>,
+//   /// Camera control parameters
+//   #[serde(skip_serializing_if = "Option::is_none")]
+//   pub camera_control: Option<String>,
+//   /// The CFG (Classifier Free Guidance) scale is a measure of how close you want
+//   /// the model to stick to your prompt.
+//   #[serde(skip_serializing_if = "Option::is_none")]
+//   pub cfg_scale: Option<f64>,
+//   /// The duration of the generated video in seconds
+//   #[serde(skip_serializing_if = "Option::is_none")]
+//   pub duration: Option<String>,
+//   #[serde(skip_serializing_if = "Option::is_none")]
+//   pub negative_prompt: Option<String>,
+//   pub prompt: String,
+// }
+// 
+#[derive(Debug, Serialize, Deserialize, Default)]
+pub struct ValidationError {
+  pub loc: Vec<serde_json::Value>,
+  pub msg: String,
+  #[serde(rename = "type")]
+  pub ty: String,
+}
+// 
+// #[derive(Debug, Serialize, Deserialize, Default)]
+// pub struct VideoEffectsOutput {
+//   /// The generated video
+//   /// {"content_type":"video/mp4","file_name":"output.mp4","url":"https://storage.googleapis.com/falserverless/kling/kling_ex.mp4.mp4"}
+//   pub video: File,
+// }
+// 
+// #[derive(Debug, Serialize, Deserialize, Default)]
+// pub struct VideoEffectsRequest {
+//   /// The duration of the generated video in seconds
+//   #[serde(skip_serializing_if = "Option::is_none")]
+//   pub duration: Option<String>,
+//   /// The effect scene to use for the video generation
+//   /// "hug"
+//   pub effect_scene: String,
+//   /// URL of the image to be used for the squish and expansion video
+//   /// "https://h2.inkwai.com/bs2/upload-ylab-stunt/se/ai_portal_queue_mmu_image_upscale_aiweb/3214b798-e1b4-4b00-b7af-72b5b0417420_raw_image_0.jpg"
+//   pub image_url: String,
+//   /// URL of images to be used for hug, kiss or heart_gesture video.
+//   /// ["https://storage.googleapis.com/falserverless/juggernaut_examples/VHXMavzPyI27zi6JseyL4.png","https://storage.googleapis.com/falserverless/juggernaut_examples/QEW5VrzccxGva7mPfEXjf.png"]
+//   #[serde(skip_serializing_if = "Option::is_none")]
+//   pub input_image_urls: Option<Vec<Option<String>>>,
+// }
+
+/// Kling 1.0
+///
+/// Category: text-to-video
+/// Machine Type: A100
+///
+///
+/// Kling 1.6 (pro) Image to Video API.
+pub fn image_to_video(
+  params: MasterImageToVideoRequest,
+) -> FalRequest<MasterImageToVideoRequest, I2VOutput> {
+  FalRequest::new("fal-ai/kling-video/v2.1/master/image-to-video", params)
+}

crates/vendor/fal-rs/src/endpoints/fal_ai/kling_video/v2_1/master/mod.rs

@@ -0,0 +1,14 @@
+#[cfg(any(
+  feature = "endpoints",
+  feature = "endpoints_fal-ai",
+  feature = "endpoints_fal-ai_kling-video"
+))]
+#[cfg_attr(
+  docsrs,
+  doc(cfg(any(
+    feature = "endpoints",
+    feature = "endpoints_fal-ai",
+    feature = "endpoints_fal-ai_kling-video"
+  )))
+)]
+pub mod image_to_video;

crates/vendor/fal-rs/src/endpoints/fal_ai/kling_video/v2_1/mod.rs

@@ -0,0 +1,28 @@
+#[cfg(any(
+  feature = "endpoints",
+  feature = "endpoints_fal-ai",
+  feature = "endpoints_fal-ai_kling-video"
+))]
+#[cfg_attr(
+  docsrs,
+  doc(cfg(any(
+    feature = "endpoints",
+    feature = "endpoints_fal-ai",
+    feature = "endpoints_fal-ai_kling-video"
+  )))
+)]
+pub mod master;
+#[cfg(any(
+  feature = "endpoints",
+  feature = "endpoints_fal-ai",
+  feature = "endpoints_fal-ai_kling-video"
+))]
+#[cfg_attr(
+  docsrs,
+  doc(cfg(any(
+    feature = "endpoints",
+    feature = "endpoints_fal-ai",
+    feature = "endpoints_fal-ai_kling-video"
+  )))
+)]
+pub mod pro;

crates/vendor/fal-rs/src/endpoints/fal_ai/kling_video/v2_1/pro/image_to_video/mod.rs

@@ -0,0 +1,241 @@
+#[allow(unused_imports)]
+use crate::prelude::*;
+#[allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[allow(unused_imports)]
+use std::collections::HashMap;
+
+// #[derive(Debug, Serialize, Deserialize, Default)]
+// pub struct CameraControl {
+//   /// The type of camera movement
+//   /// "horizontal"
+//   pub movement_type: String,
+//   /// The value of the camera movement
+//   /// 10
+//   pub movement_value: i64,
+// }
+
+// #[derive(Debug, Serialize, Deserialize, Default)]
+// pub struct DynamicMask {
+//   /// URL of the image for Dynamic Brush Application Area (Mask image created by users using the motion brush)
+//   /// "https://h2.inkwai.com/bs2/upload-ylab-stunt/ai_portal/1732888130/WU8spl23dA/dynamic_mask_1.png"
+//   pub mask_url: String,
+//   /// List of trajectories
+//   /// [{"x":279,"y":219},{"x":417,"y":65}]
+//   #[serde(skip_serializing_if = "Option::is_none")]
+//   pub trajectories: Option<Vec<Option<Trajectory>>>,
+// }
+
+#[derive(Debug, Serialize, Deserialize, Default)]
+pub struct File {
+  /// The mime type of the file.
+  /// "image/png"
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub content_type: Option<String>,
+  /// File data
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub file_data: Option<String>,
+  /// The name of the file. It will be auto-generated if not provided.
+  /// "z9RV14K95DvU.png"
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub file_name: Option<String>,
+  /// The size of the file in bytes.
+  /// 4404019
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub file_size: Option<i64>,
+  /// The URL where the file can be downloaded from.
+  pub url: String,
+}
+
+#[derive(Debug, Serialize, Deserialize, Default)]
+pub struct HTTPValidationError {
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub detail: Option<Vec<Option<ValidationError>>>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct I2VOutput {
+  /// The generated video
+  /// {"url":"https://v2.fal.media/files/36087878b0c1435bb75c19b64b7db178_output.mp4"}
+  pub video: File,
+}
+
+#[derive(Debug, Serialize, Deserialize, Default)]
+pub struct ImageToVideoRequest {
+  /// The aspect ratio of the generated video frame
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub aspect_ratio: Option<String>,
+  /// The CFG (Classifier Free Guidance) scale is a measure of how close you want
+  /// the model to stick to your prompt.
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub cfg_scale: Option<f64>,
+  /// The duration of the generated video in seconds
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub duration: Option<String>,
+  pub image_url: String,
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub negative_prompt: Option<String>,
+  pub prompt: String,
+}
+
+// #[derive(Debug, Serialize, Deserialize, Default)]
+// pub struct KlingV1I2VOutput {
+//   /// The generated video
+//   /// {"url":"https://v3.fal.media/files/kangaroo/VUmAU3JvzS7mxwdgSU9zj_output.mp4"}
+//   pub video: File,
+// }
+
+#[derive(Debug, Serialize, Deserialize, Default)]
+pub struct ProImageToVideoRequest {
+  /// The aspect ratio of the generated video frame
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub aspect_ratio: Option<String>,
+  /// The CFG (Classifier Free Guidance) scale is a measure of how close you want
+  /// the model to stick to your prompt.
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub cfg_scale: Option<f64>,
+  /// The duration of the generated video in seconds
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub duration: Option<String>,
+  pub image_url: String,
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub negative_prompt: Option<String>,
+  pub prompt: String,
+  /// URL of the image to be used for the end of the video
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub tail_image_url: Option<String>,
+}
+
+// #[derive(Debug, Serialize, Deserialize, Default)]
+// pub struct T2VOutput {
+//   /// The generated video
+//   /// {"url":"https://v2.fal.media/files/fb33a862b94d4d7195e610e4cbc5d392_output.mp4"}
+//   pub video: File,
+// }
+// 
+// #[derive(Debug, Serialize, Deserialize, Default)]
+// pub struct TextToVideoRequest {
+//   /// The aspect ratio of the generated video frame
+//   #[serde(skip_serializing_if = "Option::is_none")]
+//   pub aspect_ratio: Option<String>,
+//   /// The CFG (Classifier Free Guidance) scale is a measure of how close you want
+//   /// the model to stick to your prompt.
+//   #[serde(skip_serializing_if = "Option::is_none")]
+//   pub cfg_scale: Option<f64>,
+//   /// The duration of the generated video in seconds
+//   #[serde(skip_serializing_if = "Option::is_none")]
+//   pub duration: Option<String>,
+//   #[serde(skip_serializing_if = "Option::is_none")]
+//   pub negative_prompt: Option<String>,
+//   pub prompt: String,
+// }
+// 
+// #[derive(Debug, Serialize, Deserialize, Default)]
+// pub struct Trajectory {
+//   /// X coordinate of the motion trajectory
+//   /// 279
+//   pub x: i64,
+//   /// Y coordinate of the motion trajectory
+//   /// 219
+//   pub y: i64,
+// }
+// 
+// #[derive(Debug, Serialize, Deserialize, Default)]
+// pub struct V1ImageToVideoRequest {
+//   /// The aspect ratio of the generated video frame
+//   #[serde(skip_serializing_if = "Option::is_none")]
+//   pub aspect_ratio: Option<String>,
+//   /// The CFG (Classifier Free Guidance) scale is a measure of how close you want
+//   /// the model to stick to your prompt.
+//   #[serde(skip_serializing_if = "Option::is_none")]
+//   pub cfg_scale: Option<f64>,
+//   /// The duration of the generated video in seconds
+//   #[serde(skip_serializing_if = "Option::is_none")]
+//   pub duration: Option<String>,
+//   /// List of dynamic masks
+//   #[serde(skip_serializing_if = "Option::is_none")]
+//   pub dynamic_masks: Option<Vec<Option<DynamicMask>>>,
+//   /// URL of the image to be used for the video
+//   /// "https://h2.inkwai.com/bs2/upload-ylab-stunt/se/ai_portal_queue_mmu_image_upscale_aiweb/3214b798-e1b4-4b00-b7af-72b5b0417420_raw_image_0.jpg"
+//   pub image_url: String,
+//   #[serde(skip_serializing_if = "Option::is_none")]
+//   pub negative_prompt: Option<String>,
+//   /// The prompt for the video
+//   /// "The astronaut stood up and walked away"
+//   pub prompt: String,
+//   /// URL of the image for Static Brush Application Area (Mask image created by users using the motion brush)
+//   /// "https://h2.inkwai.com/bs2/upload-ylab-stunt/ai_portal/1732888177/cOLNrShrSO/static_mask.png"
+//   #[serde(skip_serializing_if = "Option::is_none")]
+//   pub static_mask_url: Option<String>,
+//   /// URL of the image to be used for the end of the video
+//   #[serde(skip_serializing_if = "Option::is_none")]
+//   pub tail_image_url: Option<String>,
+// }
+// 
+// #[derive(Debug, Serialize, Deserialize, Default)]
+// pub struct V1TextToVideoRequest {
+//   /// Advanced Camera control parameters
+//   #[serde(skip_serializing_if = "Option::is_none")]
+//   pub advanced_camera_control: Option<Option<CameraControl>>,
+//   /// The aspect ratio of the generated video frame
+//   #[serde(skip_serializing_if = "Option::is_none")]
+//   pub aspect_ratio: Option<String>,
+//   /// Camera control parameters
+//   #[serde(skip_serializing_if = "Option::is_none")]
+//   pub camera_control: Option<String>,
+//   /// The CFG (Classifier Free Guidance) scale is a measure of how close you want
+//   /// the model to stick to your prompt.
+//   #[serde(skip_serializing_if = "Option::is_none")]
+//   pub cfg_scale: Option<f64>,
+//   /// The duration of the generated video in seconds
+//   #[serde(skip_serializing_if = "Option::is_none")]
+//   pub duration: Option<String>,
+//   #[serde(skip_serializing_if = "Option::is_none")]
+//   pub negative_prompt: Option<String>,
+//   pub prompt: String,
+// }
+// 
+#[derive(Debug, Serialize, Deserialize, Default)]
+pub struct ValidationError {
+  pub loc: Vec<serde_json::Value>,
+  pub msg: String,
+  #[serde(rename = "type")]
+  pub ty: String,
+}
+// 
+// #[derive(Debug, Serialize, Deserialize, Default)]
+// pub struct VideoEffectsOutput {
+//   /// The generated video
+//   /// {"content_type":"video/mp4","file_name":"output.mp4","url":"https://storage.googleapis.com/falserverless/kling/kling_ex.mp4.mp4"}
+//   pub video: File,
+// }
+// 
+// #[derive(Debug, Serialize, Deserialize, Default)]
+// pub struct VideoEffectsRequest {
+//   /// The duration of the generated video in seconds
+//   #[serde(skip_serializing_if = "Option::is_none")]
+//   pub duration: Option<String>,
+//   /// The effect scene to use for the video generation
+//   /// "hug"
+//   pub effect_scene: String,
+//   /// URL of the image to be used for the squish and expansion video
+//   /// "https://h2.inkwai.com/bs2/upload-ylab-stunt/se/ai_portal_queue_mmu_image_upscale_aiweb/3214b798-e1b4-4b00-b7af-72b5b0417420_raw_image_0.jpg"
+//   pub image_url: String,
+//   /// URL of images to be used for hug, kiss or heart_gesture video.
+//   /// ["https://storage.googleapis.com/falserverless/juggernaut_examples/VHXMavzPyI27zi6JseyL4.png","https://storage.googleapis.com/falserverless/juggernaut_examples/QEW5VrzccxGva7mPfEXjf.png"]
+//   #[serde(skip_serializing_if = "Option::is_none")]
+//   pub input_image_urls: Option<Vec<Option<String>>>,
+// }
+
+/// Kling 1.0
+///
+/// Category: text-to-video
+/// Machine Type: A100
+///
+///
+/// Kling 1.6 (pro) Image to Video API.
+pub fn image_to_video(
+  params: ProImageToVideoRequest,
+) -> FalRequest<ProImageToVideoRequest, I2VOutput> {
+  FalRequest::new("fal-ai/kling-video/v2.1/pro/image-to-video", params)
+}

crates/vendor/fal-rs/src/endpoints/fal_ai/kling_video/v2_1/pro/mod.rs

@@ -0,0 +1,14 @@
+#[cfg(any(
+  feature = "endpoints",
+  feature = "endpoints_fal-ai",
+  feature = "endpoints_fal-ai_kling-video"
+))]
+#[cfg_attr(
+  docsrs,
+  doc(cfg(any(
+    feature = "endpoints",
+    feature = "endpoints_fal-ai",
+    feature = "endpoints_fal-ai_kling-video"
+  )))
+)]
+pub mod image_to_video;

crates/vendor/fal-rs/src/endpoints/fal_ai/mod.rs

@@ -138,6 +138,20 @@ pub mod birefnet;
     )))
 )]
 pub mod bria;
+#[cfg(any(
+    feature = "endpoints",
+    feature = "endpoints_fal-ai",
+    feature = "endpoints_fal-ai_bytedance"
+))]
+#[cfg_attr(
+    docsrs,
+    doc(cfg(any(
+        feature = "endpoints",
+        feature = "endpoints_fal-ai",
+        feature = "endpoints_fal-ai_bytedance"
+    )))
+)]
+pub mod bytedance;
 #[cfg(any(
     feature = "endpoints",
     feature = "endpoints_fal-ai",

crates/vendor/fal-rs/src/queue.rs

@@ -22,11 +22,14 @@ pub enum Status {
     Completed,
 }
 
+// NB(bt, 2025-06-13): Some of these fields have started to become optional.
+// eg, errors:
+//   "missing field `source`", line: 1, column: 1019
 #[derive(Debug, Serialize, Deserialize)]
 pub struct RequestLog {
     pub timestamp: String,
-    pub level: String,
-    pub source: String,
+    pub level: Option<String>, // NB(bt): Now optional
+    pub source: Option<String>, // NB(bt): Now optional
     pub message: String,
 }
 

frontend/apps/editor3d/app/src/components/signaled/TopBar/TopBar.tsx

@@ -43,11 +43,17 @@ const appMenuTabs: MenuIconItem[] = [
     id: "2D",
     label: "2D Canvas",
     icon: <FontAwesomeIcon icon={faPaintbrush} />,
+    imageSrc: "/resources/gifs/artcraft-canvas-demo.gif",
+    description: "Easy edits. Great for graphic design.",
+    large: true,
   },
   {
     id: "3D",
     label: "3D Editor",
     icon: <FontAwesomeIcon icon={faCube} />,
+    imageSrc: "/resources/gifs/artcraft-3d-demo.gif",
+    description: "Precision control. Great for AI film.",
+    large: true,
   },
   {
     id: "IMAGE",

frontend/apps/editor3d/app/src/pages/PageDraw/Node.ts

@@ -20,6 +20,8 @@ export interface NodeProps {
   scaleY?: number;
   offsetX?: number;
   offsetY?: number;
+  zIndex?: number;
+  locked?: boolean;
 }
 
 export class Node {
@@ -42,6 +44,8 @@ export class Node {
   scaleY: number;
   offsetX: number;
   offsetY: number;
+  zIndex: number;
+  locked: boolean;
   
   constructor({
     id,
@@ -62,7 +66,9 @@ export class Node {
     scaleX = 1,
     scaleY = 1,
     offsetX = 0,
-    offsetY = 0
+    offsetY = 0,
+    zIndex = 0,
+    locked = false
   }: NodeProps) {
     this.id = id;
     this.x = x;
@@ -83,6 +89,8 @@ export class Node {
     this.scaleY = scaleY;
     this.offsetX = offsetX;
     this.offsetY = offsetY;
+    this.zIndex = zIndex;
+    this.locked = locked;
   }
 
   setPosition(x: number, y: number): void {

frontend/apps/editor3d/app/src/pages/PageDraw/PageDraw.tsx

@@ -1,6 +1,7 @@
 import { useState, useRef, useEffect } from "react";
 import { PaintSurface } from "./PaintSurface";
 // https://github.com/SaladTechnologies/comfyui-api
+
 import "./App.css";
 import PromptEditor from "./PromptEditor/PromptEditor";
 import SideToolbar from "./components/ui/SideToolbar";
@@ -14,9 +15,46 @@ import { FontAwesomeIcon } from "@fortawesome/react-fontawesome";
 import { faClock, faImage } from "@fortawesome/pro-solid-svg-icons";
 import Konva from "konva"; // just for types
 
-import { setCanvasRenderBitmap } from "../../signals/canvasRenderBitmap";
-import { captureStageImageBitmap } from "./hooks/useUpdateSnapshot";
+import { setCanvasRenderBitmap } from "../../signals/canvasRenderBitmap"
+import { captureStageImageBitmap } from "./hooks/useUpdateSnapshot"
 import { ContextMenuContainer } from "./components/ui/ContextMenu";
+import {
+  FalBackgroundRemoval,
+  FalBackgroundRemovalRequest,
+} from "@storyteller/tauri-api";
+
+
+  /**
+ * This decodes Base64 encoded PNG images into an image element.
+ * @param base64String a standard (not "web safe") base64-encoded string
+ */
+  export const DecodeBase64ToImage = async (base64String: string) : Promise<ImageBitmap> => {
+    // Create an image element
+    const img = document.createElement("img");
+  
+    // Convert base64 to data URL if it doesn't include the prefix
+    const dataUrl = base64String.startsWith("data:")
+      ? base64String
+      : `data:image/png;base64,${base64String}`;
+  
+    // Create a promise to handle the image loading
+    return new Promise((resolve, reject) => {
+      img.onload = async () => {
+        try {
+          const bitmap = await createImageBitmap(img);
+          resolve(bitmap);
+        } catch (error) {
+          reject(error);
+        }
+      };
+  
+      img.onerror = () => reject(new Error("Failed to load image"));
+  
+      // Set the source to trigger loading
+      img.src = dataUrl;
+    });
+  }
+
 const PageDraw = () => {
   //useStateSceneLoader();
 
@@ -271,23 +309,98 @@ const PageDraw = () => {
         activeToolId={store.activeTool}
       />
       <div className="relative z-0">
-        <ContextMenuContainer>
-          <PaintSurface
-            nodes={store.nodes}
-            selectedNodeIds={store.selectedNodeIds}
-            onCanvasSizeChange={(width: number, height: number): void => {
-              canvasWidth.current = width;
-              canvasHeight.current = height;
-            }}
-            fillColor={store.fillColor}
-            activeTool={store.activeTool}
-            brushColor={store.brushColor}
-            brushSize={store.brushSize}
-            onSelectionChange={setIsSelecting}
-            stageRef={stageRef}
-            transformerRefs={transformerRefs}
-          />
-        </ContextMenuContainer>
+      <ContextMenuContainer 
+        onAction={(e, action) => {
+          if (action === "contextMenu") {
+            const hasSelection = store.selectedNodeIds.length > 0;
+            if (hasSelection) {
+              console.log("An item is selected.");
+              // You can add additional actions here based on the selection
+              return true 
+            } else {
+              console.log("No item is selected.");
+              return false
+            }
+          }
+          return false
+        }} 
+        onMenuAction={async (action) => {
+          switch (action) {
+            case 'LOCK':
+              store.toggleLock(store.selectedNodeIds);
+              break;
+            case 'REMOVE_BACKGROUND':
+              // returns a success if we have selected images only
+              await store.removeBackground(store.selectedNodeIds, 
+                async (success: boolean, image_base64: string, message: string) => {
+                if (!success) {
+                  console.error(message);
+                  return { success: false };
+                }
+                try {
+                  const response = await FalBackgroundRemoval({ base64_image: image_base64 });
+                  if (response.status !== "success" || !("payload" in response)) {
+                    console.error("Failed to remove background", response);
+                    return { success: false };
+                  }
+
+                  const base64String = response.payload?.base64_bytes as string;
+                  const binaryString = atob(base64String);
+                  const bytes = Uint8Array.from(binaryString, c => c.charCodeAt(0));
+                  const blob = new Blob([bytes], { type: "image/png" });
+                  const file = new File([blob], "generated_image.png", { type: blob.type });
+                  return { success: true, file };
+                } catch (error) {
+                  console.error("Failed to remove background", error);
+                  return { success: false };
+                }
+              });
+              break;
+            case 'BRING_TO_FRONT':
+              store.bringToFront(store.selectedNodeIds);
+              break;
+            case 'BRING_FORWARD':
+              store.bringForward(store.selectedNodeIds);
+              break;
+            case 'SEND_BACKWARD':
+              store.sendBackward(store.selectedNodeIds);
+              break;
+            case 'SEND_TO_BACK':
+              store.sendToBack(store.selectedNodeIds);
+              break;
+            case 'DUPLICATE':
+              store.copySelectedItems()
+              store.pasteItems()
+              break;
+            case 'DELETE':
+              store.deleteSelectedItems()
+              break;
+            default:
+              // No action needed for unhandled cases
+          }
+        }}
+        isLocked={store.selectedNodeIds.some(id => {
+          const node = store.nodes.find(n => n.id === id);
+          const lineNode = store.lineNodes.find(n => n.id === id);
+          return (node?.locked || lineNode?.locked) ?? false;
+        })}
+      >
+        <PaintSurface
+          nodes={store.nodes}
+          selectedNodeIds={store.selectedNodeIds}
+          onCanvasSizeChange={(width: number, height: number): void => {
+            canvasWidth.current = width;
+            canvasHeight.current = height;
+          }}
+          fillColor={store.fillColor}
+          activeTool={store.activeTool}
+          brushColor={store.brushColor}
+          brushSize={store.brushSize}
+          onSelectionChange={setIsSelecting}
+          stageRef={stageRef}
+          transformerRefs={transformerRefs}
+        />
+          </ContextMenuContainer>
       </div>
       <div className="absolute bottom-6 left-6 z-20 flex items-center gap-2">
         <PopoverMenu

frontend/apps/editor3d/app/src/pages/PageDraw/PaintSurface.tsx

@@ -185,13 +185,7 @@ export const PaintSurface = ({
       isWithinLeftPanel(stagePoint)
     ) {
       const lineId = `line-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-      let opacity;
-
-      if (activeTool === "draw") {
-        opacity = store.brushOpacity
-      } else {
-        opacity = 1
-      }
+      let opacity = activeTool === "draw" ? store.brushOpacity : 1;
 
       const newLineNode: LineNode = {
         id: lineId,
@@ -200,10 +194,10 @@ export const PaintSurface = ({
         stroke: activeTool === "draw" ? brushColor : fillColor || "#ffffff",
         strokeWidth: brushSize / stage.scaleX(),
         draggable: true,
-        opacity: opacity  // Add opacity to the line node
+        opacity: opacity
       };
       store.selectNode(null);
-      store.addLineNode(newLineNode);
+      store.addLineNode(newLineNode, false);  // Don't save state when starting line
       setCurrentLineId(lineId);
       setIsDrawing(true);
       setLastPoint(stagePoint);
@@ -280,7 +274,6 @@ export const PaintSurface = ({
         y: (point.y - stage.y()) / stage.scaleY(),
       };
 
-      // Only add point if it's within the left panel bounds
       if (isWithinLeftPanel(stagePoint)) {
         const currentLine = store.lineNodes.find(
           (line) => line.id === currentLineId,
@@ -291,7 +284,7 @@ export const PaintSurface = ({
             stagePoint.x,
             stagePoint.y,
           ];
-          store.updateLineNode(currentLineId, { points: updatedPoints });
+          store.updateLineNode(currentLineId, { points: updatedPoints }, false);  // Don't save state while drawing
         }
         setLastPoint(stagePoint);
       } else {
@@ -339,6 +332,10 @@ export const PaintSurface = ({
   };
 
   const handleStageMouseUp = () => {
+    if (isDrawing) {
+      store.saveState();  // Save state only when the stroke is complete
+    }
+
     if (isSelecting && selectionRect) {
       // Calculate the bounds of the selection rectangle
       const left = Math.min(selectionRect.startX, selectionRect.endX);
@@ -546,6 +543,25 @@ export const PaintSurface = ({
         return;
       }
 
+      // allow selection
+      if (e.evt.button === 2) {
+        const node = store.nodes.find(n => n.id === nodeId);
+        const lineNode = store.lineNodes.find(n => n.id === nodeId);
+        const isLocked = (node?.locked || lineNode?.locked) ?? false;
+        
+        // If locked, only allow selection for context menu
+        if (isLocked) {
+          store.selectNode(nodeId);
+          return;
+        }
+      }
+      
+      // Don't select locked nodes
+      const node = nodes.find(n => n.id === nodeId) || store.lineNodes.find(n => n.id === nodeId);
+      if (node?.locked) {
+        return;
+      }
+
       // Check if Ctrl/Cmd key is pressed
       const isMultiSelect = e.evt.ctrlKey || e.evt.metaKey;
 
@@ -762,7 +778,7 @@ export const PaintSurface = ({
             onMouseLeave={handleNodeMouseLeave}
             draggable={draggableIfToolsNotActive(
               activeTool,
-              lineNode.draggable,
+              lineNode.draggable && lineNode.locked == false,
             )}
             onDragMove={(e) => handleLineDragMove(e, lineNode.id)}
             onDragStart={(e) => handleLineDragStart(e, lineNode.id)}
@@ -774,6 +790,7 @@ export const PaintSurface = ({
             rotation={lineNode.rotation || 0}
             offsetX={lineNode.offsetX || 0}
             offsetY={lineNode.offsetY || 0}
+            zIndex={lineNode.zIndex}
           />
           {renderTransformer()}
         </React.Fragment>
@@ -791,13 +808,14 @@ export const PaintSurface = ({
             height={node.height}
             fill={node.fill}
             stroke={node.stroke}
-            strokeWidth={node.strokeWidth}
+            strokeWidth={0}
             rotation={node.rotation || 0}
             scaleX={node.scaleX || 1}
             scaleY={node.scaleY || 1}
             offsetX={node.offsetX || 0}
             offsetY={node.offsetY || 0}
-            draggable={draggableIfToolsNotActive(activeTool, node.draggable)}
+            zIndex={node.zIndex}
+            draggable={draggableIfToolsNotActive(activeTool, node.draggable && node.locked == false)}
             onMouseDown={(e) => handleNodeMouseDown(e, node.id)}
             onTap={(e) => handleNodeMouseDown(e, node.id)}
             onMouseEnter={handleNodeMouseEnter}
@@ -822,13 +840,14 @@ export const PaintSurface = ({
             height={node.height}
             fill={node.fill}
             stroke={node.stroke}
-            strokeWidth={node.strokeWidth}
+            strokeWidth={0}
             rotation={node.rotation || 0}
             scaleX={node.scaleX || 1}
             scaleY={node.scaleY || 1}
             offsetX={node.offsetX || 0}
             offsetY={node.offsetY || 0}
-            draggable={draggableIfToolsNotActive(activeTool, node.draggable)}
+            zIndex={node.zIndex}
+            draggable={draggableIfToolsNotActive(activeTool, node.draggable && node.locked == false)}
             onMouseDown={(e) => handleNodeMouseDown(e, node.id)}
             onTap={(e) => handleNodeMouseDown(e, node.id)}
             onMouseEnter={handleNodeMouseEnter}
@@ -853,13 +872,14 @@ export const PaintSurface = ({
             radius={Math.min(node.width, node.height) / 2}
             fill={node.fill}
             stroke={node.stroke}
-            strokeWidth={node.strokeWidth}
+            strokeWidth={0}
             rotation={node.rotation || 0}
             scaleX={node.scaleX || 1}
             scaleY={node.scaleY || 1}
             offsetX={node.offsetX || 0}
             offsetY={node.offsetY || 0}
-            draggable={draggableIfToolsNotActive(activeTool, node.draggable)}
+            zIndex={node.zIndex}
+            draggable={draggableIfToolsNotActive(activeTool, node.draggable && node.locked == false)}
             onMouseDown={(e) => handleNodeMouseDown(e, node.id)}
             onTap={(e) => handleNodeMouseDown(e, node.id)}
             onMouseEnter={handleNodeMouseEnter}
@@ -892,6 +912,7 @@ export const PaintSurface = ({
               offsetX={node.offsetX || 0}
               offsetY={node.offsetY || 0}
               listening={false}
+              zIndex={node.zIndex}
             />
           )}
           <Image
@@ -906,7 +927,7 @@ export const PaintSurface = ({
             scaleY={node.scaleY || 1}
             offsetX={node.offsetX || 0}
             offsetY={node.offsetY || 0}
-            draggable={draggableIfToolsNotActive(activeTool, node.draggable)}
+            draggable={draggableIfToolsNotActive(activeTool, node.draggable && node.locked == false)}
             onMouseDown={(e) => handleNodeMouseDown(e, node.id)}
             onTap={(e) => handleNodeMouseDown(e, node.id)}
             onMouseEnter={handleNodeMouseEnter}
@@ -999,7 +1020,12 @@ export const PaintSurface = ({
               />
 
               {/* Render all nodes including line nodes */}
-              {[...nodes, ...store.lineNodes].map((node) => renderNode(node))}
+              {[...nodes, ...store.lineNodes]
+                .sort((a, b) => (a.zIndex || 0) - (b.zIndex || 0))
+                .map((node, index) => {
+                // console.log(`Node ${index}:`, node);
+                return renderNode(node);
+              })}
 
               {/* Render selection rectangle */}
               {selectionRect && (

frontend/apps/editor3d/app/src/pages/PageDraw/components/ui/ContextMenu.tsx

@@ -1,24 +1,26 @@
 import React, { useEffect, useRef } from 'react';
+import { createPortal } from 'react-dom';
 
-interface MenuPosition {
+export interface MenuPosition {
   x: number;
   y: number;
 }
 
-interface MenuItem {
+export interface MenuItem {
   icon: React.ReactNode;
   label: string;
-  onClick: () => void;
+  action: string;  // Instead of onClick, we use an action identifier
   divider?: boolean;
 }
 
 interface ContextMenuProps {
   items: MenuItem[];
+  onAction: (action: string) => void;  // Single callback for all menu items
   onClose: () => void;
   position: MenuPosition;
 }
 
-export const ContextMenu: React.FC<ContextMenuProps> = ({ items, onClose, position }) => {
+export const ContextMenu: React.FC<ContextMenuProps> = ({ items, onAction, onClose, position }) => {
   const menuRef = useRef<HTMLDivElement>(null);
 
   useEffect(() => {
@@ -32,20 +34,20 @@ export const ContextMenu: React.FC<ContextMenuProps> = ({ items, onClose, positi
     return () => document.removeEventListener('mousedown', handleClickOutside);
   }, [onClose]);
 
-  return (
+  return createPortal(
     <div
       ref={menuRef}
       style={{
         left: `${position.x}px`,
         top: `${position.y}px`,
       }}
-      className="fixed z-50 min-w-[220px] bg-[#1A1A1A] rounded-lg shadow-xl border border-[#333333] py-1 select-none"
+      className="fixed z-[9999999] min-w-[220px] bg-[#1A1A1A] rounded-lg shadow-xl border border-[#333333] py-1 select-none"
     >
       {items.map((item, index) => (
         <React.Fragment key={index}>
           <button
             onClick={() => {
-              item.onClick();
+              onAction(item.action);  // Pass the action identifier up
               onClose();
             }}
             className="w-full px-4 py-2.5 flex items-center gap-3 hover:bg-[#333333] text-[#ECECEC] text-[13px] transition-colors duration-75 ease-in-out"
@@ -58,113 +60,78 @@ export const ContextMenu: React.FC<ContextMenuProps> = ({ items, onClose, positi
           {item.divider && <div className="h-[1px] bg-[#333333] mx-2 my-1" />}
         </React.Fragment>
       ))}
-    </div>
+    </div>,
+    document.body
   );
 };
 
-// Example usage with icons
-const menuItems: MenuItem[] = [
-  {
-    icon: <svg className="w-4 h-4" viewBox="0 0 24 24" fill="none" stroke="currentColor">
-      <path d="M12 3L4 7.5L12 12L20 7.5L12 3Z" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round"/>
-      <path d="M4 16.5L12 21L20 16.5" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round"/>
-      <path d="M4 12L12 16.5L20 12" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round"/>
-    </svg>,
-    label: 'Convert to 3D',
-    onClick: () => console.log('Convert to 3D')
-  },
-  {
-    icon: <svg className="w-4 h-4" viewBox="0 0 24 24" fill="none" stroke="currentColor">
-      <path d="M4 4v16h16M4 20l16-16" strokeWidth="2" strokeLinecap="round"/>
-    </svg>,
-    label: 'Remove background',
-    onClick: () => console.log('Remove background')
-  },
-  {
-    icon: <svg className="w-4 h-4" viewBox="0 0 24 24" fill="none" stroke="currentColor">
-      <path d="M12 10V14M8 6H16C17.1046 6 18 6.89543 18 8V16C18 17.1046 17.1046 18 16 18H8C6.89543 18 6 17.1046 6 16V8C6 6.89543 6.89543 6 8 6Z" strokeWidth="2" strokeLinecap="round"/>
-    </svg>,
-    label: 'Lock',
-    onClick: () => console.log('Lock'),
-    divider: true
-  },
-  {
-    icon: <svg className="w-4 h-4" viewBox="0 0 24 24" fill="none" stroke="currentColor">
-      <path d="M5 15L12 8L19 15" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round"/>
-    </svg>,
-    label: 'Bring to front',
-    onClick: () => console.log('Bring to front')
-  },
-  {
-    icon: <svg className="w-4 h-4" viewBox="0 0 24 24" fill="none" stroke="currentColor">
-      <path d="M8 14L12 10L16 14" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round"/>
-    </svg>,
-    label: 'Bring forward',
-    onClick: () => console.log('Bring forward')
-  },
-  {
-    icon: <svg className="w-4 h-4" viewBox="0 0 24 24" fill="none" stroke="currentColor">
-      <path d="M8 10L12 14L16 10" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round"/>
-    </svg>,
-    label: 'Send backward',
-    onClick: () => console.log('Send backward')
-  },
-  {
-    icon: <svg className="w-4 h-4" viewBox="0 0 24 24" fill="none" stroke="currentColor">
-      <path d="M5 9L12 16L19 9" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round"/>
-    </svg>,
-    label: 'Send to back',
-    onClick: () => console.log('Send to back'),
-    divider: true
-  },
-  {
-    icon: <svg className="w-4 h-4" viewBox="0 0 24 24" fill="none" stroke="currentColor">
-      <path d="M16 8V6M16 8H8M16 8V16M8 8V6M8 8V16M8 16H6M8 16H16M16 16H18M6 6H8M8 6H16M16 6H18" strokeWidth="2" strokeLinecap="round"/>
-    </svg>,
-    label: 'Duplicate',
-    onClick: () => console.log('Duplicate')
-  },
-  {
-    icon: <svg className="w-4 h-4" viewBox="0 0 24 24" fill="none" stroke="currentColor">
-      <path d="M7 16L17 8M7 8L17 16" strokeWidth="2" strokeLinecap="round"/>
-    </svg>,
-    label: 'Flip Horizontal',
-    onClick: () => console.log('Flip Horizontal')
-  },
-  {
-    icon: <svg className="w-4 h-4" viewBox="0 0 24 24" fill="none" stroke="currentColor">
-      <path d="M8 7L16 17M8 17L16 7" strokeWidth="2" strokeLinecap="round"/>
-    </svg>,
-    label: 'Flip Vertical',
-    onClick: () => console.log('Flip Vertical')
-  },
-  {
-    icon: <svg className="w-4 h-4" viewBox="0 0 24 24" fill="none" stroke="currentColor">
-      <path d="M4 12V6C4 4.89543 4.89543 4 6 4H18C19.1046 4 20 4.89543 20 6V18C20 19.1046 19.1046 20 18 20H12" strokeWidth="2" strokeLinecap="round"/>
-      <path d="M9 15H4V20" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round"/>
-    </svg>,
-    label: 'Fit to screen',
-    onClick: () => console.log('Fit to screen')
-  }
-];
+interface ContextMenuContainerProps {
+  children: React.ReactNode;
+  items?: MenuItem[];
+  onAction?: (e: React.MouseEvent, actionName: string) => boolean | void;
+  onMenuAction?: (action: string) => void;
+  className?: string;
+  isLocked?: boolean;
+}
 
-// Container component that handles the right-click
-export const ContextMenuContainer: React.FC<{ children: React.ReactNode }> = ({ children }) => {
+export const ContextMenuContainer: React.FC<ContextMenuContainerProps> = ({ 
+  children, 
+  items = defaultMenuItems,
+  onAction,
+  onMenuAction,
+  className = '',
+  isLocked = false
+}) => {
   const [showMenu, setShowMenu] = React.useState(false);
   const [position, setPosition] = React.useState<MenuPosition>({ x: 0, y: 0 });
 
+  const filteredItems = React.useMemo(() => {
+    if (isLocked) {
+      return [
+        {
+          icon: <svg className="w-4 h-4" viewBox="0 0 24 24" fill="none" stroke="currentColor">
+            <path d="M8 11V7a4 4 0 118 0m-4 8v2m-6 4h12a2 2 0 002-2v-6a2 2 0 00-2-2H6a2 2 0 00-2 2v6a2 2 0 002 2z" strokeWidth="2" strokeLinecap="round"/>
+          </svg>,
+          label: 'Unlock',
+          action: 'LOCK'
+        }
+      ];
+    }
+    return items;
+  }, [isLocked, items]);
+
   const handleContextMenu = (e: React.MouseEvent) => {
     e.preventDefault();
-    setPosition({ x: e.clientX, y: e.clientY });
-    setShowMenu(true);
+    const newPosition = { x: e.clientX, y: e.clientY };
+    setPosition(newPosition);
+    
+    const shouldShowMenu = onAction?.(e, 'contextMenu');
+    if (shouldShowMenu !== undefined) {
+      setShowMenu(shouldShowMenu);
+    } else {
+      setShowMenu(true);
+    }
+  };
+
+  const handleClick = (e: React.MouseEvent) => {
+    onAction?.(e, 'click');
+  };
+
+  const handleMenuAction = (action: string) => {
+    onMenuAction?.(action);
   };
 
   return (
-    <div onContextMenu={handleContextMenu} className="w-full h-full">
+    <div 
+      onClick={handleClick}
+      onContextMenu={handleContextMenu} 
+      className={`w-full h-full relative z-[99999] ${className}`}
+    >
       {children}
       {showMenu && (
         <ContextMenu
-          items={menuItems}
+          items={filteredItems}
+          onAction={handleMenuAction}
           position={position}
           onClose={() => setShowMenu(false)}
         />
@@ -172,3 +139,78 @@ export const ContextMenuContainer: React.FC<{ children: React.ReactNode }> = ({
     </div>
   );
 };
+
+// Default menu items now use action identifiers instead of callbacks
+const defaultMenuItems: MenuItem[] = [
+  {
+    icon: <svg className="w-4 h-4" viewBox="0 0 24 24" fill="none" stroke="currentColor">
+      <path d="M4 4v16h16M4 20l16-16" strokeWidth="2" strokeLinecap="round"/>
+    </svg>,
+    label: 'Remove background',
+    action: 'REMOVE_BACKGROUND'
+  },
+  {
+    icon: <svg className="w-4 h-4" viewBox="0 0 24 24" fill="none" stroke="currentColor">
+      <path d="M12 10V14M8 6H16C17.1046 6 18 6.89543 18 8V16C18 17.1046 17.1046 18 16 18H8C6.89543 18 6 17.1046 6 16V8C6 6.89543 6.89543 6 8 6Z" strokeWidth="2" strokeLinecap="round"/>
+    </svg>,
+    label: 'Lock',
+    action: 'LOCK',
+    divider: true
+  },
+  {
+    icon: <svg className="w-4 h-4" viewBox="0 0 24 24" fill="none" stroke="currentColor">
+      <path d="M5 15L12 8L19 15" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round"/>
+    </svg>,
+    label: 'Bring to front',
+    action: 'BRING_TO_FRONT'
+  },
+  {
+    icon: <svg className="w-4 h-4" viewBox="0 0 24 24" fill="none" stroke="currentColor">
+      <path d="M8 14L12 10L16 14" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round"/>
+    </svg>,
+    label: 'Bring forward',
+    action: 'BRING_FORWARD'
+  },
+  {
+    icon: <svg className="w-4 h-4" viewBox="0 0 24 24" fill="none" stroke="currentColor">
+      <path d="M8 10L12 14L16 10" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round"/>
+    </svg>,
+    label: 'Send backward',
+    action: 'SEND_BACKWARD'
+  },
+  {
+    icon: <svg className="w-4 h-4" viewBox="0 0 24 24" fill="none" stroke="currentColor">
+      <path d="M5 9L12 16L19 9" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round"/>
+    </svg>,
+    label: 'Send to back',
+    action: 'SEND_TO_BACK',
+    divider: true
+  },
+  {
+    icon: <svg className="w-4 h-4" viewBox="0 0 24 24" fill="none" stroke="currentColor">
+      <path d="M16 8V6M16 8H8M16 8V16M8 8V6M8 8V16M8 16H6M8 16H16M16 16H18M6 6H8M8 6H16M16 6H18" strokeWidth="2" strokeLinecap="round"/>
+    </svg>,
+    label: 'Duplicate',
+    action: 'DUPLICATE'
+  },
+  {
+    icon: (
+      <svg
+        className="w-4 h-4"
+        viewBox="0 0 24 24"
+        fill="none"
+        stroke="currentColor"
+      >
+        <path
+          d="M19 7l-.867 12.142A2 2 0 0116.138 21H7.862a2 2 0 01-1.995-1.858L5 7m5 4v6m4-6v6M9 7h6m-7 0V4a1 1 0 011-1h4a1 1 0 011 1v3"
+          strokeWidth="2"
+          strokeLinecap="round"
+          strokeLinejoin="round"
+        />
+      </svg>
+    ),
+    label: 'Delete',
+    action: 'DELETE'
+  },
+];
+

frontend/apps/editor3d/app/src/pages/PageDraw/stores/SceneState.ts

@@ -17,6 +17,30 @@ export type LineNode = {
   scaleY?: number;
   offsetX?: number;
   offsetY?: number;
+  zIndex: number;
+  locked?: boolean; // Add locked property
+};
+
+
+   // Logic to remove background from image nodes would go here
+const convertFileToBase64 = (file: File): Promise<string> => {
+    return new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        
+        reader.onloadend = () => {
+            if (reader.result) {
+                resolve(reader.result as string);
+            } else {
+                reject(new Error("Failed to convert file to base64."));
+            }
+        };
+        
+        reader.onerror = () => {
+            reject(new Error("Error reading file."));
+        };
+        
+        reader.readAsDataURL(file);
+    });
 };
 
 export type ActiveTool = 'select' | 'draw' | 'eraser' | 'backgroundColor' | 'shape';
@@ -65,9 +89,9 @@ interface SceneState {
   saveState: () => void;
   
   // Add new actions for line nodes
-  addLineNode: (lineNode: LineNode) => void;
+  addLineNode: (lineNode: LineNode, shouldSaveState: boolean) => void;
   removeLineNode: (id: string, shouldSaveState?: boolean) => void;
-  updateLineNode: (id: string, updates: Partial<LineNode>) => void;
+  updateLineNode: (id: string, updates: Partial<LineNode>, shouldSaveState: boolean) => void;
   moveLineNode: (id: string, dx: number, dy: number) => void;
   
   // Add a specific method for file uploads
@@ -103,6 +127,16 @@ interface SceneState {
   // Add these two properties
   serializeSceneToString: () => Promise<string>;
   loadSceneFromString: (jsonString: string) => boolean;
+
+  // New functions
+  bringToFront: (nodeIds: string[]) => void;
+  sendToBack: (nodeIds: string[]) => void;
+  bringForward: (nodeIds: string[]) => void;
+  sendBackward: (nodeIds: string[]) => void;
+  removeBackground: (nodeIds: string[], operation: (success: boolean,base64_image:string, message: string) => Promise<{ success: boolean; file?: File }>) => Promise<void>;
+
+  // Add new lock action
+  toggleLock: (nodeIds: string[]) => void;
 }
 
 const generateId = (): string => {
@@ -112,6 +146,22 @@ const generateId = (): string => {
 // Add a flag to prevent saving state during restoration
 let isRestoring = false;
 
+// Add this helper function at the top of the store (before create<SceneState>)
+const getNextZIndex = (nodes: Node[], lineNodes: LineNode[]): number => {
+  const allZIndices = [
+    ...nodes.map((n, index) => {
+      //console.log(`Node: ${JSON.stringify(n)}, Index: ${index}`);
+      return n.zIndex || 0;
+    }),
+    ...lineNodes.map((n, index) => {
+      //console.log(`LineNode: ${JSON.stringify(n)}, Index: ${index}`);
+      return n.zIndex || 0;
+    })
+  ];
+
+  return allZIndices.length > 0 ? Math.max(...allZIndices) + 1 : 0;
+};
+
 export const useSceneStore = create<SceneState>((set, get) => ({
   // Initial state
   nodes: [],
@@ -135,8 +185,17 @@ export const useSceneStore = create<SceneState>((set, get) => ({
   // Actions
   addNode: (node: Node) => {
     set((state) => {
-      const newNodes = [...state.nodes, node];
-      return { nodes: newNodes };
+      const nextZ = getNextZIndex(state.nodes, state.lineNodes);
+      console.log(`NextZ for node ID ${node.id}: ${nextZ}`);
+      const newNode = new Node({
+        ...node,
+        zIndex: nextZ
+      });
+      // console.log("New Node with ID:", newNode.id);
+      let nodes =  [...state.nodes, newNode]
+      console.log("Nodes after update")
+      console.log(nodes)
+      return { nodes: nodes };
     });
     get().saveState();
   },
@@ -161,9 +220,17 @@ export const useSceneStore = create<SceneState>((set, get) => ({
   
   updateNode: (id: string, updates: Partial<Node>, shouldSaveState: boolean = true) => {
     set((state) => {
+   
       const newNodes = state.nodes.map(node => {
+        let newZIndex = updates.zIndex !== undefined ? updates.zIndex : node.zIndex 
+        
+
         if (node.id === id) {
-          return new Node({ ...node, ...updates });
+          return new Node({ 
+            ...node, 
+            ...updates,
+            zIndex: newZIndex
+          });
         }
         return node;
       });
@@ -449,12 +516,18 @@ export const useSceneStore = create<SceneState>((set, get) => ({
   },
   
   // Add new line node actions
-  addLineNode: (lineNode: LineNode) => {
+  addLineNode: (lineNode: LineNode, shouldSaveState: boolean = true) => {
     set((state) => {
-      const newLineNodes = [...state.lineNodes, lineNode];
-      return { lineNodes: newLineNodes };
+      const nextZ = getNextZIndex(state.nodes, state.lineNodes);
+      const newLineNode = {
+        ...lineNode,
+        zIndex: nextZ
+      };
+      return { lineNodes: [...state.lineNodes, newLineNode] };
     });
-    get().saveState();
+    if (shouldSaveState) {
+      get().saveState();
+    }
   },
   
   removeLineNode: (id: string, shouldSaveState: boolean = true) => {
@@ -475,17 +548,23 @@ export const useSceneStore = create<SceneState>((set, get) => ({
     }
   },
   
-  updateLineNode: (id: string, updates: Partial<LineNode>) => {
+  updateLineNode: (id: string, updates: Partial<LineNode>, shouldSaveState: boolean = true) => {
     set((state) => {
       const newLineNodes = state.lineNodes.map(node => {
         if (node.id === id) {
-          return { ...node, ...updates };
+          return { 
+            ...node, 
+            ...updates,
+            zIndex: updates.zIndex !== undefined ? updates.zIndex : node.zIndex 
+          };
         }
         return node;
       });
       return { lineNodes: newLineNodes };
     });
-    get().saveState();
+    if (shouldSaveState) {
+      get().saveState();
+    }
   },
   
   moveLineNode: (id: string, dx: number, dy: number) => {
@@ -517,7 +596,8 @@ export const useSceneStore = create<SceneState>((set, get) => ({
         const img = new Image();
         img.onload = () => {
           const aspectRatio = img.naturalWidth / img.naturalHeight;
-          const finalWidth = width || Math.min(img.naturalWidth, 300);
+          // Increase default size to 512px width while maintaining aspect ratio
+          const finalWidth = width || Math.min(img.naturalWidth, 512);
           const finalHeight = height || finalWidth / aspectRatio;
           console.log('Image loaded with dimensions:', {
             naturalWidth: img.naturalWidth,
@@ -585,11 +665,11 @@ export const useSceneStore = create<SceneState>((set, get) => ({
     // Load the image asynchronously
     node.setImage(source).then(() => {
       // Update the node in the store after image loads
-      console.log('Image loaded for node:', node.id);
-      get().updateNode(node.id, node, false);
+      get().addNode(node);
+      //get().updateNode(node.id, node, false);
     }).catch((error)=>console.error('Error loading image:', error));
     
-    get().addNode(node);
+    
   },
 
   // Action for deleting selected items
@@ -888,5 +968,284 @@ export const useSceneStore = create<SceneState>((set, get) => ({
   },
   loadSceneFromString: (jsonString: string): boolean => {
     return get().importSceneFromJson(jsonString);
+  },
+
+  // New functions
+  bringToFront: (nodeIds: string[]) => {
+    set(state => {
+      // Get highest zIndex from all nodes and line nodes
+      const allZIndices = [
+        ...state.nodes.map(n => n.zIndex || 0),
+        ...state.lineNodes.map(n => n.zIndex || 0)
+      ];
+      const maxZ = Math.max(...allZIndices, 0) + 1;
+
+      return {
+        nodes: state.nodes.map(node => 
+          nodeIds.includes(node.id) 
+            ? new Node({ ...node, zIndex: maxZ })
+            : node
+        ),
+        lineNodes: state.lineNodes.map(node =>
+          nodeIds.includes(node.id)
+            ? { ...node, zIndex: maxZ }
+            : node
+        )
+      };
+    });
+    get().saveState();
+  },
+
+  sendToBack: (nodeIds: string[]) => {
+    set(state => {
+      // Get lowest zIndex from all nodes and line nodes
+      const allZIndices = [
+        ...state.nodes.map(n => n.zIndex || 0),
+        ...state.lineNodes.map(n => n.zIndex || 0)
+      ];
+      const minZ = Math.min(...allZIndices, 0) - 1;
+
+      return {
+        nodes: state.nodes.map(node =>
+          nodeIds.includes(node.id)
+            ? new Node({ ...node, zIndex: minZ })
+            : node
+        ),
+        lineNodes: state.lineNodes.map(node =>
+          nodeIds.includes(node.id)
+            ? { ...node, zIndex: minZ }
+            : node
+        )
+      };
+    });
+    get().saveState();
+  },
+
+  bringForward: (nodeIds: string[]) => {
+    set(state => {
+      // Combine all items with their current zIndex
+      const allItems = [
+        ...state.nodes.map(n => ({ id: n.id, z: Math.max(0, n.zIndex || 0), selected: nodeIds.includes(n.id) })),
+        ...state.lineNodes.map(n => ({ id: n.id, z: Math.max(0, n.zIndex || 0), selected: nodeIds.includes(n.id) }))
+      ].sort((a, b) => a.z - b.z);
+
+      // Find the highest z-index among selected items
+      const selectedItems = allItems.filter(item => item.selected);
+      if (selectedItems.length === 0) return state;
+      
+      const highestSelectedZ = Math.max(...selectedItems.map(item => item.z));
+
+      // Find the closest item above our selection
+      const nextItem = allItems.find(item => !item.selected && item.z > highestSelectedZ);
+
+      // If no item above, swap with the highest non-selected item
+      if (!nextItem) {
+        const highestNonSelected = allItems.filter(item => !item.selected)
+                                         .sort((a, b) => b.z - a.z)[0];
+        if (!highestNonSelected) return state;
+
+        // Swap positions
+        return {
+          nodes: state.nodes.map(node => {
+            if (nodeIds.includes(node.id)) {
+              return new Node({ ...node, zIndex: highestNonSelected.z });
+            }
+            if (node.id === highestNonSelected.id) {
+              return new Node({ ...node, zIndex: highestSelectedZ });
+            }
+            return node;
+          }),
+          lineNodes: state.lineNodes.map(node => {
+            if (nodeIds.includes(node.id)) {
+              return { ...node, zIndex: highestNonSelected.z };
+            }
+            if (node.id === highestNonSelected.id) {
+              return { ...node, zIndex: highestSelectedZ };
+            }
+            return node;
+          })
+        };
+      }
+
+      const newZ = nextItem.z;
+      return {
+        nodes: state.nodes.map(node => {
+          if (nodeIds.includes(node.id)) {
+            return new Node({ ...node, zIndex: newZ });
+          }
+          if (node.id === nextItem.id) {
+            return new Node({ ...node, zIndex: highestSelectedZ });
+          }
+          return node;
+        }),
+        lineNodes: state.lineNodes.map(node => {
+          if (nodeIds.includes(node.id)) {
+            return { ...node, zIndex: newZ };
+          }
+          if (node.id === nextItem.id) {
+            return { ...node, zIndex: highestSelectedZ };
+          }
+          return node;
+        })
+      };
+    });
+    get().saveState();
+  },
+
+  sendBackward: (nodeIds: string[]) => {
+    set(state => {
+      // Combine all items with their current zIndex
+      const allItems = [
+        ...state.nodes.map(n => ({ id: n.id, z: Math.max(0, n.zIndex || 0), selected: nodeIds.includes(n.id) })),
+        ...state.lineNodes.map(n => ({ id: n.id, z: Math.max(0, n.zIndex || 0), selected: nodeIds.includes(n.id) }))
+      ].sort((a, b) => b.z - a.z);
+
+      // Find the lowest z-index among selected items
+      const selectedItems = allItems.filter(item => item.selected);
+      if (selectedItems.length === 0) return state;
+
+      const lowestSelectedZ = Math.min(...selectedItems.map(item => item.z));
+
+      // Find the closest item below our selection
+      const nextItem = allItems.find(item => !item.selected && item.z < lowestSelectedZ);
+
+      // If no item below, swap with the lowest non-selected item
+      if (!nextItem) {
+        const lowestNonSelected = allItems.filter(item => !item.selected)
+                                        .sort((a, b) => a.z - b.z)[0];
+        if (!lowestNonSelected) return state;
+
+        // Swap positions
+        return {
+          nodes: state.nodes.map(node => {
+            if (nodeIds.includes(node.id)) {
+              return new Node({ ...node, zIndex: lowestNonSelected.z });
+            }
+            if (node.id === lowestNonSelected.id) {
+              return new Node({ ...node, zIndex: lowestSelectedZ });
+            }
+            return node;
+          }),
+          lineNodes: state.lineNodes.map(node => {
+            if (nodeIds.includes(node.id)) {
+              return { ...node, zIndex: lowestNonSelected.z };
+            }
+            if (node.id === lowestNonSelected.id) {
+              return { ...node, zIndex: lowestSelectedZ };
+            }
+            return node;
+          })
+        };
+      }
+
+      const newZ = nextItem.z;
+      return {
+        nodes: state.nodes.map(node => {
+          if (nodeIds.includes(node.id)) {
+            return new Node({ ...node, zIndex: newZ });
+          }
+          if (node.id === nextItem.id) {
+            return new Node({ ...node, zIndex: lowestSelectedZ });
+          }
+          return node;
+        }),
+        lineNodes: state.lineNodes.map(node => {
+          if (nodeIds.includes(node.id)) {
+            return { ...node, zIndex: newZ };
+          }
+          if (node.id === nextItem.id) {
+            return { ...node, zIndex: lowestSelectedZ };
+          }
+          return node;
+        })
+      };
+    });
+    get().saveState();
+  },
+  removeBackground: async (nodeIds: string[], operation:  (success: boolean, base64_image:string,message: string) => Promise<{ success: boolean; file?: File }>) => {
+   
+    const hasImageNodes = nodeIds.some(id => {
+        const node = get().nodes.find(n => n.id === id);
+        return node ? node.type === 'image': false;
+    });
+    let callbackSuccess = false
+    if (hasImageNodes) {
+        console.log("Selected nodes include image types.");
+     
+        const firstNode = get().nodes.find(node => nodeIds.includes(node.id) && node.type === 'image');
+        if (firstNode) {
+            const imageFile = firstNode.imageFile; // Assuming the file is stored in the node
+            if (imageFile !== undefined) {
+              try {
+                const base64Image = await convertFileToBase64(imageFile);
+                console.log("Base64 Image:", base64Image);
+                // Additional logic to handle the base64 image can be added here
+                const { success, file } = await operation(true, base64Image, "Removing Background."); // Indicate success in removing background
+                callbackSuccess = success;
+                if (callbackSuccess) {
+                  // save the state of the image.
+                  set((state: SceneState) => ({
+                    nodes: state.nodes.map((node: Node) => {
+                      if (node.id === firstNode.id) {
+                        // Create an object URL for immediate preview if needed
+                        console.log("Updated Node!")
+                        const updatedImageUrl: string | undefined = file ? URL.createObjectURL(file) : node.imageUrl;
+                        return new Node({
+                          ...node,
+                          imageFile: file,
+                          imageUrl: updatedImageUrl,
+                        });
+                      }
+                      return node;
+                    }),
+                  }));
+                
+                }
+              } catch (error) {
+                console.error("Error converting file to base64:", error);
+              }
+            }
+            console.log("Image File:", imageFile);
+        } else {
+            console.warn("No image node found or first node is not an image.");
+        }
+    } else {
+        console.log("No selected nodes are of image type.");
+        operation(false,"","Did not select a Images"); // Indicate failure to remove background
+    }
+  
+  },
+
+  // Add toggleLock action
+  toggleLock: (nodeIds: string[]) => {
+    set((state) => {
+      // Update regular nodes
+      const updatedNodes = state.nodes.map(node => {
+        if (nodeIds.includes(node.id)) {
+          return new Node({
+            ...node,
+            locked: !node.locked
+          });
+        }
+        return node;
+      });
+
+      // Update line nodes
+      const updatedLineNodes = state.lineNodes.map(node => {
+        if (nodeIds.includes(node.id)) {
+          return {
+            ...node,
+            locked: !node.locked
+          };
+        }
+        return node;
+      });
+
+      return {
+        nodes: updatedNodes,
+        lineNodes: updatedLineNodes
+      };
+    });
+    get().saveState();
   }
 }));

frontend/apps/editor3d/app/src/pages/PageEnigma/PageEditor.tsx

@@ -6,7 +6,7 @@ import { ControlsTopButtons } from "./comps/ControlsTopButtons";
 import { ControlPanelSceneObject } from "./comps/ControlPanelSceneObject";
 import { PreviewEngineCamera } from "./comps/PreviewEngineCamera";
 import { PreviewFrameImage } from "./comps/PreviewFrameImage";
-import { pageHeight, pageWidth } from "~/signals";
+import { authentication, pageHeight, pageWidth } from "~/signals";
 import { PoseModeSelector } from "./comps/PoseModeSelector";
 import ImageToVideo from "../PageVideo/ImageToVideo";
 import TextToImage from "../PageImage/TextToImage";
@@ -21,6 +21,7 @@ import {
   enableHotkeyInput,
   gridVisibility,
   setGridVisibility,
+  DomLevels,
 } from "~/pages/PageEnigma/signals";
 import { EditorCanvas } from "./comps/EngineCanvases";
 import { SceneContainer } from "./comps/SceneContainer";
@@ -53,7 +54,7 @@ import {
 } from "~/components/signaled/TopBar/TopBar";
 import { uploadPlaneFromMediaToken } from "~/components/reusable/UploadModalMedia/uploadPlane";
 import { addObject } from "./signals/objectGroup/addObject";
-import { AssetType } from "~/enums";
+import { AssetType, AUTH_STATUS } from "~/enums";
 import { v4 as uuidv4 } from "uuid";
 import { MediaItem } from "~/pages/PageEnigma/models";
 import { UploaderState } from "~/models";
@@ -71,7 +72,7 @@ import {
   // videoGenerationModels,
   // useModelSelectorStore,
 } from "@storyteller/ui-model-selector";
-
+import { LoginModal } from "@storyteller/ui-login-modal";
 import PageDraw from "../PageDraw/PageDraw";
 import { useTabStore } from "../Stores/TabState";
 
@@ -541,7 +542,7 @@ export const PageEditor = () => {
         </div>
       )}
 
-      {/*<LoginModal
+      <LoginModal
         onClose={() => {}}
         videoSrc2D="/resources/videos/artcraft-canvas-demo.mp4"
         videoSrc3D="/resources/videos/artcraft-3d-demo.mp4"
@@ -557,7 +558,7 @@ export const PageEditor = () => {
           authentication.status.value = AUTH_STATUS.LOGGED_IN;
           authentication.userInfo.value = userInfo;
         }}
-      /> */}
+      />
     </div>
   );
 };

frontend/apps/editor3d/app/src/pages/PageEnigma/comps/Controls3D/Controls3D.tsx

@@ -8,19 +8,42 @@ import {
 import { ButtonIconSelect } from "@storyteller/ui-button-icon-select";
 import { Button } from "@storyteller/ui-button";
 import { Tooltip } from "@storyteller/ui-tooltip";
+import {
+  showActionReminder,
+  isActionReminderOpen,
+} from "@storyteller/ui-action-reminder-modal";
+import { SettingsModal } from "@storyteller/ui-settings-modal";
 import { EngineContext } from "../../contexts/EngineContext";
-import { useContext, useEffect, useState } from "react";
+import { useContext, useEffect, useState, useRef, useCallback } from "react";
 import { assetModalVisibleDuringDrag, assetModalVisible } from "../../signals";
+import {
+  Create3dModal,
+  useCreate3dModalStore,
+  // eslint-disable-next-line import/no-unresolved
+} from "@storyteller/ui-create-3d-modal";
+// import { v4 as uuidv4 } from "uuid";
+// import { addObject } from "../../signals/objectGroup/addObject";
+// import { MediaItem } from "../../models/assets";
+import { GetFalApiKey } from "@storyteller/tauri-api"; // Fix import path
+// eslint-disable-next-line import/no-unresolved
+// import { AssetType } from "~/enums";
 import { AssetModal } from "../AssetMenu/AssetModal";
 import { selectedMode } from "../../signals/selectedMode";
 import { useSignals } from "@preact/signals-react/runtime";
 import { outlinerState } from "../../signals/outliner/outliner";
 import { twMerge } from "tailwind-merge";
+// eslint-disable-next-line import/no-unresolved
+import { setLogoutStates } from "~/signals/authentication/utilities";
 
 export const Controls3D = () => {
   useSignals();
   const editorEngine = useContext(EngineContext);
   const [showEmptySceneTooltip, setShowEmptySceneTooltip] = useState(false);
+  // Action reminder is now handled through signals
+  const [isSettingsModalOpen, setIsSettingsModalOpen] = useState(false);
+
+  // Track processed 3D models by their media token to prevent duplicates
+  const processedModelsRef = useRef<Record<string, boolean>>({});
 
   useEffect(() => {
     // Check if scene is empty and onboarding helper is not visible
@@ -79,6 +102,85 @@ export const Controls3D = () => {
     editorEngine.change_mode("scale");
   };
 
+  // ----- TODO LATER - BFlat for auto add 3d model to scene -----
+
+  // Function to add the generated 3D model to the scene
+  // const addGeneratedModelToScene = useCallback((mediaToken: string) => {
+  //   console.log("[DEBUG] addGeneratedModelToScene called with token:", mediaToken);
+
+  //   // Create a MediaItem object for the 3D model
+  //   const mediaItem: MediaItem = {
+  //     version: 1,
+  //     type: AssetType.OBJECT,
+  //     media_id: mediaToken,
+  //     name: "3D Model",
+  //     object_uuid: uuidv4(),
+  //   };
+
+  //   // Add the object to the scene
+  //   console.log("[DEBUG] Calling addObject with:", mediaItem);
+  //   try {
+  //     addObject(mediaItem);
+  //     console.log("[DEBUG] addObject called successfully");
+  //   } catch (error) {
+  //     console.error("[DEBUG] Error in addObject:", error);
+  //   }
+  // }, []);
+
+  const handleOpenModal = () => {
+    assetModalVisibleDuringDrag.value = true;
+    assetModalVisible.value = true;
+  };
+
+  const handleOpenCreate3dModal = async () => {
+    try {
+      const falApiKeyResult = await GetFalApiKey();
+
+      if (
+        falApiKeyResult.status === "success" &&
+        "payload" in falApiKeyResult &&
+        falApiKeyResult.payload?.key
+      ) {
+        // API key exists, open the create 3D modal
+        useCreate3dModalStore.getState().open();
+      } else {
+        // No API key, show the action reminder modal
+        showActionReminder({
+          reminderType: "default",
+          title: "FAL API Key Required",
+          message:
+            "To generate 3D models, you need to add a valid FAL API key in your settings.",
+          primaryActionText: "Add now",
+          secondaryActionText: "Cancel",
+          onPrimaryAction: () => {
+            // Close the action reminder modal first
+            isActionReminderOpen.value = false;
+            // Then open the settings modal
+            openSettingsModal();
+          },
+        });
+      }
+    } catch (error) {
+      console.error("Error checking FAL API key:", error);
+    }
+  };
+
+  const openSettingsModal = () => {
+    setIsSettingsModalOpen(true);
+  };
+
+  // Handle completed models from the Create3dModal component
+  const handleModelComplete = useCallback((mediaToken: string) => {
+    // Check if we've already processed this model
+    if (mediaToken && !processedModelsRef.current[mediaToken]) {
+      // Mark this model as processed to avoid duplicates
+      processedModelsRef.current[mediaToken] = true;
+
+      // Add the generated 3D model to the scene
+      // addGeneratedModelToScene(mediaToken);
+    }
+  }, []);
+
   const modes = [
     {
       value: "move",
@@ -100,11 +202,6 @@ export const Controls3D = () => {
     },
   ];
 
-  const handleOpenModal = () => {
-    assetModalVisibleDuringDrag.value = true;
-    assetModalVisible.value = true;
-  };
-
   return (
     <>
       <div className="flex justify-center">
@@ -148,10 +245,9 @@ export const Controls3D = () => {
               >
                 <Button
                   icon={faMagicWandSparkles}
-                  className="text-md h-9 w-9 rounded-[10px] bg-white/10"
+                  className="text-md h-9 w-9 rounded-[10px] bg-white/15 transition-colors hover:bg-white/25"
                   variant="secondary"
-                  disabled={true}
-                  onClick={handleOpenModal}
+                  onClick={handleOpenCreate3dModal}
                 />
               </Tooltip>
             </div>
@@ -167,6 +263,15 @@ export const Controls3D = () => {
       </div>
 
       <AssetModal />
+
+      <Create3dModal onModelComplete={handleModelComplete} />
+
+      <SettingsModal
+        isOpen={isSettingsModalOpen}
+        onClose={() => setIsSettingsModalOpen(false)}
+        globalAccountLogoutCallback={() => setLogoutStates()}
+        initialSection="accounts"
+      />
     </>
   );
 };

frontend/apps/editor3d/tsconfig.json

@@ -28,9 +28,6 @@
     "noEmit": true
   },
   "references": [
-    {
-      "path": "../../libs/components/model-selector"
-    },
     {
       "path": "../../libs/components/pagination"
     },
@@ -49,9 +46,15 @@
     {
       "path": "../../libs/components/loading-spinner"
     },
+    {
+      "path": "../../libs/components/create-3d-modal"
+    },
     {
       "path": "../../libs/components/button-icon-select"
     },
+    {
+      "path": "../../libs/components/slider-v2"
+    },
     {
       "path": "../../libs/components/tab-selector"
     },
@@ -61,32 +64,29 @@
     {
       "path": "../../libs/components/button-dropdown"
     },
+    {
+      "path": "../../libs/tauri-api"
+    },
     {
       "path": "../../libs/components/action-reminder-modal"
     },
-    {
-      "path": "../../libs/components/login-modal"
-    },
-    {
-      "path": "../../libs/soundboard"
-    },
-    {
-      "path": "../../libs/components/slider-v2"
-    },
     {
       "path": "../../libs/components/toaster"
     },
     {
-      "path": "../../libs/components/popover"
+      "path": "../../libs/components/model-selector"
+    },
+    {
+      "path": "../../libs/soundboard"
     },
     {
       "path": "../../libs/components/promptbox"
     },
     {
-      "path": "../../libs/common"
+      "path": "../../libs/components/popover"
     },
     {
-      "path": "../../libs/tauri-api"
+      "path": "../../libs/common"
     },
     {
       "path": "../../libs/components/menu-icon-selector"