Background removal race condition fixed.

- draggable and resizable lightbox

Bug found: if lightbox is open, gallery modal cannot open the filter
dropdown until lightbox is closed.

.sqlx/query-0fa824822cd94024dce21243f41e69e4a3e8685c4de676834a7c0ee14982c976.json

@@ -0,0 +1,12 @@
+{
+  "db_name": "MySQL",
+  "query": "\nINSERT INTO generic_inference_jobs\nSET\n  token = ?,\n  uuid_idempotency_token = ?,\n\n  job_type = ?,\n\n  maybe_external_third_party = ?,\n  maybe_external_third_party_id = ?,\n\n  product_category = ?,\n  inference_category = ?,\n\n  maybe_model_type = NULL,\n  maybe_model_token = NULL,\n\n  maybe_input_source_token = NULL,\n  maybe_input_source_token_type = NULL,\n\n  maybe_download_url = NULL,\n  maybe_cover_image_media_file_token = NULL,\n\n  maybe_raw_inference_text = NULL,\n\n  maybe_inference_args = ?,\n\n  maybe_creator_user_token = ?,\n  maybe_creator_anonymous_visitor_token = ?,\n  creator_ip_address = ?,\n  creator_set_visibility = ?,\n\n  priority_level = 0,\n  is_keepalive_required = FALSE,\n  max_duration_seconds = 0,\n\n  is_debug_request = FALSE,\n  maybe_routing_tag = NULL,\n\n  status = ?\n        ",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 13
+    },
+    "nullable": []
+  },
+  "hash": "0fa824822cd94024dce21243f41e69e4a3e8685c4de676834a7c0ee14982c976"
+}

.sqlx/query-64dfacc1f0552d539f009fea91e902a2fe296c06ad539808596bbf2c8fc9eaa0.json

@@ -0,0 +1,113 @@
+{
+  "db_name": "MySQL",
+  "query": "\nSELECT\n    jobs.token as `job_token: tokens::tokens::generic_inference_jobs::InferenceJobToken`,\n\n    jobs.status as `status: enums::common::job_status_plus::JobStatusPlus`,\n    \n    jobs.maybe_external_third_party as `external_third_party: enums::by_table::generic_inference_jobs::inference_job_external_third_party::InferenceJobExternalThirdParty`,\n    jobs.maybe_external_third_party_id as `external_third_party_id`,\n\n    jobs.maybe_creator_user_token as `maybe_creator_user_token: tokens::tokens::users::UserToken`,\n    jobs.maybe_creator_anonymous_visitor_token as `maybe_creator_anonymous_visitor_token: tokens::tokens::anonymous_visitor_tracking::AnonymousVisitorTrackingToken`,\n    jobs.creator_ip_address,\n\n    jobs.created_at,\n    jobs.updated_at\n\nFROM generic_inference_jobs as jobs\n\nWHERE jobs.maybe_external_third_party = ?\nAND jobs.maybe_external_third_party_id = ?\n        ",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "job_token: tokens::tokens::generic_inference_jobs::InferenceJobToken",
+        "type_info": {
+          "type": "VarString",
+          "flags": "NOT_NULL | UNIQUE_KEY | BINARY | NO_DEFAULT_VALUE",
+          "char_set": 224,
+          "max_size": 128
+        }
+      },
+      {
+        "ordinal": 1,
+        "name": "status: enums::common::job_status_plus::JobStatusPlus",
+        "type_info": {
+          "type": "String",
+          "flags": "NOT_NULL | MULTIPLE_KEY | BINARY | ENUM",
+          "char_set": 224,
+          "max_size": 76
+        }
+      },
+      {
+        "ordinal": 2,
+        "name": "external_third_party: enums::by_table::generic_inference_jobs::inference_job_external_third_party::InferenceJobExternalThirdParty",
+        "type_info": {
+          "type": "VarString",
+          "flags": "MULTIPLE_KEY | BINARY",
+          "char_set": 224,
+          "max_size": 64
+        }
+      },
+      {
+        "ordinal": 3,
+        "name": "external_third_party_id",
+        "type_info": {
+          "type": "VarString",
+          "flags": "MULTIPLE_KEY | BINARY",
+          "char_set": 224,
+          "max_size": 256
+        }
+      },
+      {
+        "ordinal": 4,
+        "name": "maybe_creator_user_token: tokens::tokens::users::UserToken",
+        "type_info": {
+          "type": "VarString",
+          "flags": "MULTIPLE_KEY | BINARY",
+          "char_set": 224,
+          "max_size": 128
+        }
+      },
+      {
+        "ordinal": 5,
+        "name": "maybe_creator_anonymous_visitor_token: tokens::tokens::anonymous_visitor_tracking::AnonymousVisitorTrackingToken",
+        "type_info": {
+          "type": "VarString",
+          "flags": "MULTIPLE_KEY | BINARY",
+          "char_set": 224,
+          "max_size": 128
+        }
+      },
+      {
+        "ordinal": 6,
+        "name": "creator_ip_address",
+        "type_info": {
+          "type": "VarString",
+          "flags": "NOT_NULL | MULTIPLE_KEY | BINARY | NO_DEFAULT_VALUE",
+          "char_set": 224,
+          "max_size": 160
+        }
+      },
+      {
+        "ordinal": 7,
+        "name": "created_at",
+        "type_info": {
+          "type": "Timestamp",
+          "flags": "NOT_NULL | MULTIPLE_KEY | BINARY | TIMESTAMP",
+          "char_set": 63,
+          "max_size": 19
+        }
+      },
+      {
+        "ordinal": 8,
+        "name": "updated_at",
+        "type_info": {
+          "type": "Timestamp",
+          "flags": "NOT_NULL | BINARY | TIMESTAMP | ON_UPDATE_NOW",
+          "char_set": 63,
+          "max_size": 19
+        }
+      }
+    ],
+    "parameters": {
+      "Right": 2
+    },
+    "nullable": [
+      false,
+      false,
+      true,
+      true,
+      true,
+      true,
+      false,
+      false,
+      false
+    ]
+  },
+  "hash": "64dfacc1f0552d539f009fea91e902a2fe296c06ad539808596bbf2c8fc9eaa0"
+}

.sqlx/query-b4470e607c005421dd8504b9f1d695080a581936ac6ce00b6f437b2764e741be.json

@@ -1,12 +1,12 @@
 {
   "db_name": "MySQL",
-  "query": "\n        INSERT INTO media_files\n        SET\n            token = ?,\n\n            media_class = ?,\n            media_type = ?,\n\n            is_user_upload = ?,\n            is_intermediate_system_file = ?,\n\n            origin_category = ?, \n            origin_product_category = ?, \n            maybe_origin_model_type = ?, \n            maybe_origin_model_token = ?, \n            maybe_origin_filename = ?,\n\n            is_batch_generated = ?,\n            maybe_batch_token = ?,\n\n            maybe_mime_type = ?,\n            file_size_bytes = ?,\n            maybe_duration_millis = ?,\n            maybe_audio_encoding = ?, \n            maybe_video_encoding = ?, \n            maybe_frame_width = ?, \n            maybe_frame_height = ?,\n            maybe_prompt_token = ?,\n            checksum_sha2 = ?,\n\n            maybe_title = ?,\n            maybe_text_transcript = ?,\n\n            maybe_scene_source_media_file_token = ?,\n\n            public_bucket_directory_hash = ?, \n            maybe_public_bucket_prefix = ?, \n            maybe_public_bucket_extension = ?, \n\n            maybe_creator_user_token = ?, \n            maybe_creator_anonymous_visitor_token = ?, \n\n            creator_ip_address = ?, \n            creator_set_visibility = ?, \n\n            maybe_creator_file_synthetic_id = ?, \n            maybe_creator_category_synthetic_id = ?,\n\n            extra_file_modification_info = ?,\n\n            maybe_mod_user_token = ?, \n            is_generated_on_prem = ?, \n            generated_by_worker = ?, \n            generated_by_cluster = ?\n        ",
+  "query": "\n        INSERT INTO media_files\n        SET\n            token = ?,\n\n            media_class = ?,\n            media_type = ?,\n\n            is_user_upload = ?,\n            is_intermediate_system_file = ?,\n\n            origin_category = ?, \n            origin_product_category = ?, \n            maybe_origin_model_type = ?, \n            maybe_origin_model_token = ?, \n            maybe_origin_filename = ?,\n\n            is_batch_generated = ?,\n            maybe_batch_token = ?,\n\n            maybe_mime_type = ?,\n            file_size_bytes = ?,\n            maybe_duration_millis = ?,\n            maybe_audio_encoding = ?, \n            maybe_video_encoding = ?, \n            maybe_frame_width = ?, \n            maybe_frame_height = ?,\n            maybe_prompt_token = ?,\n            checksum_sha2 = ?,\n            \n            maybe_engine_category = ?,\n\n            maybe_title = ?,\n            maybe_text_transcript = ?,\n\n            maybe_scene_source_media_file_token = ?,\n\n            public_bucket_directory_hash = ?, \n            maybe_public_bucket_prefix = ?, \n            maybe_public_bucket_extension = ?, \n\n            maybe_creator_user_token = ?, \n            maybe_creator_anonymous_visitor_token = ?, \n\n            creator_ip_address = ?, \n            creator_set_visibility = ?, \n\n            maybe_creator_file_synthetic_id = ?, \n            maybe_creator_category_synthetic_id = ?,\n\n            extra_file_modification_info = ?,\n\n            maybe_mod_user_token = ?, \n            is_generated_on_prem = ?, \n            generated_by_worker = ?, \n            generated_by_cluster = ?\n        ",
   "describe": {
     "columns": [],
     "parameters": {
-      "Right": 38
+      "Right": 39
     },
     "nullable": []
   },
-  "hash": "c58f414b5e4d0f0420d1894e2f40311e5613919f49f3ac91f81f5fc2bef1bea8"
+  "hash": "b4470e607c005421dd8504b9f1d695080a581936ac6ce00b6f437b2764e741be"
 }

.sqlx/query-f68a8917e639418a0bb952bef606c96299001e143c745ee30df99b72d1235d35.json

@@ -0,0 +1,12 @@
+{
+  "db_name": "MySQL",
+  "query": "\nUPDATE generic_inference_jobs\nSET\n  status = ?,\n  on_success_result_entity_type = ?,\n  on_success_result_entity_token = ?,\n  failure_reason = NULL,\n  internal_debugging_failure_reason = NULL,\n  success_execution_millis = NULL,\n  success_inference_execution_millis = NULL,\n  retry_at = NULL,\n  successfully_completed_at = NOW()\nWHERE token = ?\n        ",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 4
+    },
+    "nullable": []
+  },
+  "hash": "f68a8917e639418a0bb952bef606c96299001e143c745ee30df99b72d1235d35"
+}

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",
@@ -88,6 +89,7 @@ members = [
   #"crates/schema/database/sqlite_queries",
 
   # Schema (public): common strongly-typed tokens, ids, payloads, etc.
+  "crates/schema/public/api/artcraft_api_defs",
   "crates/schema/public/composite_identifiers",
   "crates/schema/public/enums",
   "crates/schema/public/enums_public",
@@ -181,6 +183,7 @@ actix-web-actors = "4.3.1+deprecated"
 actix-web-lab = "0.20.2"
 anyhow = "1.0.98"
 base64 = "0.22.1"
+bytes = "1.10.1"
 chrono = { version = "0.4.41", features = ["serde"] }
 cookie = "0.18.1"
 futures = { version = "0.3.31" }
@@ -197,18 +200,22 @@ serde_json = "1.0.140"
 serde_yaml = "0.9.34+deprecated"
 sha3 = "0.10.8"
 tauri = { version = "2.4.1", features = ["unstable", "devtools"] } # NB: "devtools" prevents App Store distribution
+tempdir = "0.3.7"
+tempfile = "3.20.0"
 thiserror = "2.0.12"
 tokio = { version = "1.45.1", features = ["macros"] }
 toml = "0.8.22"
 url = { version = "2.5.4", features = ["serde"] }
 
 # Internal libs
+artcraft_api_defs = { path = "crates/schema/public/api/artcraft_api_defs" }
 build_metadata = { path = "crates/lib/build_metadata" }
 crockford = { path = "crates/lib/data/crockford" }
 enums = { path = "crates/schema/public/enums" }
 enums_public = { path = "crates/schema/public/enums_public" }
 errors = { path = "crates/lib/errors" }
 fal_client = { path = "crates/lib/api_clients/fal_client" }
+file_to_base64_url = { path = "crates/lib/files/file_to_base64_url" }
 filesys = { path = "crates/lib/files/filesys" }
 idempotency = { path = "crates/lib/idempotency" }
 images = { path = "crates/lib/files/images" }
@@ -222,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" }

_sql/migrations_squashed/generic_inference_jobs.sql

@@ -39,6 +39,9 @@ CREATE TABLE generic_inference_jobs (
   -- Examples (may not be up to date):
   --  * text_to_speech
   --  * voice_conversion
+  --  * image_generation
+  --  * video_generation  
+  --  * background_removal
   inference_category VARCHAR(32) NOT NULL,
 
   -- If the job is externally enqueued, this is the third-party service

crates/desktop/artcraft/Cargo.toml

@@ -23,16 +23,19 @@ tauri-build = { version = "2.1.1", features = [] }
 workspace-build-acceleration = { workspace =  true }
 
 # Internal
+artcraft_api_defs = { workspace = true }
 build_metadata = { workspace = true }
 errors = { workspace = true }
 fal_client = { workspace = true }
 filesys = { workspace = true }
+idempotency = { workspace = true }
 memory_store = { workspace = true }
 mimetypes = { workspace = true }
 openai_sora_client = { workspace = true }
 primitives = { workspace = true }
 storyteller_client = { workspace = true }
 tokens = { workspace = true }
+web_base64 = { workspace = true }
 
 # External
 anyhow = { workspace = true }
@@ -54,8 +57,8 @@ serde_json = { workspace = true }
 tauri = { workspace = true }
 tauri-plugin-log = "2.3.1"
 tauri-plugin-upload = "2.2.1"
-tempdir = "0.3.7"
-tempfile = "3.18.0"
+tempdir = { workspace = true }
+tempfile = { workspace = true }
 tokio = { version = "1.42", features = ["rt", "rt-multi-thread", "fs"] }
 tokio-util = { version = "0.7", features = ["codec"] }
 url = { 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,9 +24,8 @@ 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::image_gen::enqueue_flux_pro_ultra_text_to_image::{enqueue_flux_pro_ultra_text_to_image, FluxProUltraTextToImageArgs};
-use fal_client::requests::image_gen::enqueue_recraft3_text_to_image::{enqueue_recraft3_text_to_image, Recraft3TextToImageArgs};
-use fal_client::requests::remove_background_rembg::remove_background_rembg;
+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};
@@ -56,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 {
@@ -94,6 +95,8 @@ pub enum EnqueueTextToImageErrorType {
   NeedsFalApiKey,
   /// Fal had an API error
   FalError,
+  /// Needs to be logged into Artcraft
+  NeedsStorytellerCredentials,
 }
 
 
@@ -173,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,97 @@
+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,
+        aspect_ratio: None,
+        num_images: None,
+      };
+      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::image_gen::enqueue_flux_pro_ultra_text_to_image::{enqueue_flux_pro_ultra_text_to_image, FluxProUltraTextToImageArgs};
-use fal_client::requests::image_gen::enqueue_recraft3_text_to_image::{enqueue_recraft3_text_to_image, Recraft3TextToImageArgs};
+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,8 +11,8 @@ 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::image_gen::enqueue_flux_pro_ultra_text_to_image::{enqueue_flux_pro_ultra_text_to_image, FluxProUltraTextToImageArgs};
-use fal_client::requests::image_gen::enqueue_recraft3_text_to_image::{enqueue_recraft3_text_to_image, Recraft3TextToImageArgs};
+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;
 use openai_sora_client::recipes::image_remix_with_session_auto_renew::{image_remix_with_session_auto_renew, ImageRemixAutoRenewRequest};
@@ -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 +1,3 @@
-pub mod image;
+pub mod image;
+pub mod object;
+pub mod video;

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

@@ -0,0 +1,177 @@
+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};
+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 EnqueueImageTo3dObjectRequest {
+  /// 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<EnqueueImageTo3dObjectModel>,
+}
+
+#[derive(Deserialize, Debug, Copy, Clone)]
+#[serde(rename_all = "snake_case")]
+pub enum EnqueueImageTo3dObjectModel {
+  #[serde(rename = "hunyuan_3d_2")]
+  Hunyuan3d2,
+}
+
+#[derive(Serialize)]
+pub struct EnqueueImageTo3dObjectSuccessResponse {
+}
+
+impl SerializeMarker for EnqueueImageTo3dObjectSuccessResponse {}
+
+#[derive(Serialize, Debug)]
+#[serde(rename_all = "snake_case")]
+pub enum EnqueueImageTo3dObjectErrorType {
+  /// 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_3d_object_command(
+  app: AppHandle,
+  request: EnqueueImageTo3dObjectRequest,
+  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<EnqueueImageTo3dObjectSuccessResponse, EnqueueImageTo3dObjectErrorType, ()> {
+
+  info!("enqueue_image_to_3d_object_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 = EnqueueImageTo3dObjectErrorType::ServerError;
+      let mut error_message = "A server error occurred. Please try again. If it continues, please tell our staff about the problem.";
+
+      match err {
+        InternalObjectError::NoModelSpecified => {
+          status = CommandErrorStatus::BadRequest;
+          error_type = EnqueueImageTo3dObjectErrorType::ModelNotSpecified;
+          error_message = "No model specified for image generation";
+        }
+        InternalObjectError::NeedsFalApiKey => {
+          status = CommandErrorStatus::Unauthorized;
+          error_type = EnqueueImageTo3dObjectErrorType::NeedsFalApiKey;
+          error_message = "You need to set a FAL api key";
+        },
+        InternalObjectError::NeedsStorytellerCredentials => {
+          status = CommandErrorStatus::Unauthorized;
+          error_type = EnqueueImageTo3dObjectErrorType::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(EnqueueImageTo3dObjectSuccessResponse {}.into())
+    }
+  }
+}
+
+
+pub async fn handle_request(
+  app: &AppHandle,
+  request: EnqueueImageTo3dObjectRequest,
+  app_data_root: &AppDataRoot,
+  fal_creds_manager: &FalCredentialManager,
+  storyteller_creds_manager: &StorytellerCredentialManager,
+  fal_task_queue: &FalTaskQueue,
+) -> Result<(), InternalObjectError> {
+
+  if fal_creds_manager.has_apparent_api_token()? {
+    handle_object_fal(&app, app_data_root, request, fal_creds_manager, fal_task_queue).await?;
+  } else {
+    handle_object_artcraft(request, &app, app_data_root, storyteller_creds_manager).await?;
+  }
+
+  Ok(())
+}

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

@@ -0,0 +1,129 @@
+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::object::internal_object_error::InternalObjectError;
+use crate::core::events::basic_sendable_event_trait::BasicSendableEvent;
+use crate::core::events::generation_events::common::{GenerationAction, 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 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::object::generate_hunyuan2_image_to_3d::generate_hunyuan2_image_to_3d;
+use storyteller_client::utils::api_host::ApiHost;
+use tauri::{AppHandle, State};
+
+pub async fn handle_object_artcraft(
+  request: EnqueueImageTo3dObjectRequest,
+  app: &AppHandle,
+  app_data_root: &AppDataRoot,
+  storyteller_creds_manager: &StorytellerCredentialManager,
+) -> Result<(), InternalObjectError> {
+
+  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::ImageTo3d);
+
+      if let Err(err) = event.send(&app) {
+        error!("Failed to emit event: {:?}", err); // Fail open.
+      }
+      
+      return Err(InternalObjectError::NeedsStorytellerCredentials);
+    },
+  };
+  
+  //let api_key = fal_creds_manager.get_key_required()
+  //    .map_err(|err| {
+  //      error!("EnqueueTextToImage FAL api key required: {:?}", err);
+  //      InternalObjectError::NeedsFalApiKey
+  //    })?;
+
+
+  info!("Calling Artcraft image to 3d ...");
+
+
+  let uuid_idempotency_token = generate_random_uuid();
+  
+  let job_token = match request.model {
+    None => {
+      return Err(InternalObjectError::NoModelSpecified);
+    }
+    Some(EnqueueImageTo3dObjectModel::Hunyuan3d2) => {
+      info!("enqueue Hunyuan 3D 2.0");
+      let request = GenerateHunyuan2ImageTo3dRequest { 
+        uuid_idempotency_token,
+        media_file_token: request.image_media_token,
+      };
+      let result = generate_hunyuan2_image_to_3d(
+        &ApiHost::Storyteller,
+        Some(&creds),
+        request,
+      ).await;
+      match result {
+        Ok(enqueued) => {
+          info!("Successfully enqueued Artcraft Hunyuan 3D 2.0");
+          enqueued.inference_job_token
+        }
+        Err(err) => {
+          error!("Failed to use Artcraft Hunyuan 3D 2.0: {:?}", err);
+          return Err(InternalObjectError::StorytellerError(err));
+        }
+      }
+    }
+  };
+
+  info!("Successfully enqueued 3D generation");
+  
+  let event = GenerationEnqueueSuccessEvent {
+    action: GenerationAction::ImageTo3d,
+    service: GenerationServiceProvider::Artcraft,
+    model: None,
+  };
+  
+  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(InternalObjectError::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(InternalObjectError::FalError(err));
+//    }
+//  }
+
+  Ok(())
+}

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

@@ -0,0 +1,117 @@
+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::object::internal_object_error::InternalObjectError;
+use crate::core::events::basic_sendable_event_trait::BasicSendableEvent;
+use crate::core::events::generation_events::common::{GenerationAction, 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 log::{error, info, warn};
+use tauri::AppHandle;
+
+pub async fn handle_object_fal(
+  app: &AppHandle,
+  app_data_root: &AppDataRoot,
+  request: EnqueueImageTo3dObjectRequest,
+  fal_creds_manager: &FalCredentialManager,
+  fal_task_queue: &FalTaskQueue,
+) -> Result<(), InternalObjectError> {
+
+  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::ImageTo3d);
+
+      if let Err(err) = event.send(&app) {
+        error!("Failed to emit event: {:?}", err); // Fail open.
+      }
+      
+      return Err(InternalObjectError::NeedsFalApiKey);
+    },
+  };
+  
+  //let api_key = fal_creds_manager.get_key_required()
+  //    .map_err(|err| {
+  //      error!("EnqueueTextToImage FAL api key required: {:?}", err);
+  //      InternalObjectError::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(InternalObjectError::AnyhowError(anyhow!("No image media token provided")));
+  }
+
+  info!("Calling FAL image to 3d ...");
+
+  let filename = temp_download.path().to_path_buf();
+
+  let result = match request.model {
+    None => {
+      return Err(InternalObjectError::NoModelSpecified);
+    }
+    Some(EnqueueImageTo3dObjectModel::Hunyuan3d2) => {
+      info!("enqueue Hunyuan 3D 2.0");
+      enqueue_hunyuan2_image_to_3d(Hunyuan2Args {
+        image_path: filename,
+        api_key: &api_key,
+      }).await
+    }
+  };
+
+  match result {
+    Ok(enqueued) => {
+      info!("Successfully enqueued text to image");
+
+      let event = GenerationEnqueueSuccessEvent {
+        action: GenerationAction::ImageTo3d,
+        service: GenerationServiceProvider::Fal,
+        model: None,
+      };
+
+      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(InternalObjectError::AnyhowError(anyhow!("Failed to enqueue task: {:?}", err)));
+      }
+    }
+    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(InternalObjectError::FalError(err));
+    }
+  }
+
+  Ok(())
+}

crates/desktop/artcraft/src/core/commands/enqueue/object/internal_object_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 InternalObjectError {
+  NoModelSpecified,
+  NeedsFalApiKey,
+  NeedsSoraCredentials,
+  NeedsStorytellerCredentials,
+  FalError(FalErrorPlus),
+  AnyhowError(AnyhowError),
+  StorytellerError(StorytellerError),
+  DecodeError(DecodeError),
+  IoError(std::io::Error),
+  ArtcraftError(ArtcraftError),
+}
+
+impl From<AnyhowError> for InternalObjectError {
+  fn from(value: AnyhowError) -> Self {
+    Self::AnyhowError(value)
+  }
+}
+
+impl From<FalErrorPlus> for InternalObjectError {
+  fn from(value: FalErrorPlus) -> Self {
+    Self::FalError(value)
+  }
+}
+
+impl From<StorytellerError> for InternalObjectError {
+  fn from(value: StorytellerError) -> Self {
+    Self::StorytellerError(value)
+  }
+}
+
+impl From<DecodeError> for InternalObjectError {
+  fn from(value: DecodeError) -> Self {
+    Self::DecodeError(value)
+  }
+}
+
+impl From<std::io::Error> for InternalObjectError {
+  fn from(value: std::io::Error) -> Self {
+    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/object/mod.rs

@@ -0,0 +1,4 @@
+pub mod enqueue_image_to_3d_object_command;
+pub mod handle_object_artcraft;
+pub mod handle_object_fal;
+pub mod internal_object_error;

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,139 @@
+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,
+        duration: 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

@@ -3,13 +3,16 @@ use serde::Serialize;
 #[derive(Debug, Copy, Clone, Serialize)]
 #[serde(rename_all = "snake_case")]
 pub enum GenerationServiceProvider {
-  Sora,
+  Artcraft,
   Fal,
+  Sora,
 }
 
 #[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/events/generation_events/generation_enqueue_failure_event.rs

@@ -19,6 +19,15 @@ impl BasicSendableEvent for GenerationEnqueueFailureEvent {
 }
 
 impl GenerationEnqueueFailureEvent {
+  pub fn no_artcraft_credentials(action: GenerationAction) -> Self {
+    Self {
+      action,
+      service: GenerationServiceProvider::Artcraft,
+      model: None,
+      reason: Some("Please log into Artcraft.".to_string()),
+    }
+  }
+  
   pub fn no_fal_api_key(action: GenerationAction) -> Self {
     Self {
       action,

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

@@ -6,6 +6,8 @@ use tauri::Manager;
 use crate::core::commands::app_preferences::get_app_preferences_command::get_app_preferences_command;
 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;
@@ -161,6 +163,8 @@ pub fn run() {
     .manage(storyteller_creds_manager_3)
     .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;
@@ -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::remove_background_rembg::remove_background_rembg;
+use fal_client::requests::queue::remove_background_rembg::remove_background_rembg;
 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;
@@ -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;
@@ -24,8 +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::enqueue_hunyuan2_image_to_3d::{enqueue_hunyuan2_image_to_3d, Hunyuan2Args};
-use fal_client::requests::remove_background_rembg::remove_background_rembg;
+use fal_client::requests::queue::enqueue_hunyuan2_image_to_3d::{enqueue_hunyuan2_image_to_3d, Hunyuan2Args};
 use filesys::file_read_bytes::file_read_bytes;
 use image::codecs::png::{CompressionType, FilterType, PngEncoder};
 use image::{DynamicImage, EncodableLayout, ImageReader};
@@ -50,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;
@@ -153,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 {
@@ -170,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)
   }
 }
 
@@ -188,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,
@@ -197,7 +212,6 @@ pub async fn image_to_3d(
 ) -> Result<(), InnerError> {
 
   let api_key = fal_creds_manager.get_key_required()?;
-  let creds = storyteller_creds_manager.get_credentials_required()?;
 
   let mut temp_download;
 

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,8 +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::remove_background_rembg::remove_background_rembg;
-use fal_client::requests::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};
@@ -50,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;
@@ -158,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 {
@@ -175,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)
   }
 }
 
@@ -193,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,
@@ -219,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/fal/commands/mod.rs

@@ -2,4 +2,6 @@ pub mod fal_background_removal_command;
 pub mod fal_hunyuan_image_to_3d_command;
 pub mod fal_kling_image_to_video_command;
 pub mod get_fal_api_key_command;
-pub mod set_fal_api_key_command;
+pub mod set_fal_api_key_command;
+// pub mod get_open_ai_api_key_command;
+// pub mod set_open_ai_api_key_command;

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/actix_cors_configs/src/configs/artcraft_3d.rs

@@ -14,4 +14,5 @@ pub fn add_artcraft_3d(cors: Cors, _is_production: bool) -> Cors {
       .allowed_origin("http://localhost:5173")
       .allowed_origin("http://localhost:5174") // If already started
       .allowed_origin("http://localhost:5175") // If already started
+      .allowed_origin("https://macaroni-1.tailce84f.ts.net") // TODO
 }

crates/lib/api_clients/fal_client/Cargo.toml

@@ -17,12 +17,13 @@ path = "src/lib.rs"
 workspace-build-acceleration = { workspace =  true }
 
 # Internal
-file_to_base64_url = { path = "../../files/file_to_base64_url" }
+file_to_base64_url = { workspace = true }
 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/error/fal_error_plus.rs

@@ -15,6 +15,8 @@ pub enum FalErrorPlus {
   UrlParseError(url::ParseError),
   /// An endpoint we don't support yet.
   UnhandledEndpoint(String),
+  /// Error from the `reqwest` crate.
+  ReqwestError(reqwest::Error),
 }
 
 impl Display for FalErrorPlus {
@@ -25,6 +27,7 @@ impl Display for FalErrorPlus {
       Self::AnyhowError(err) => write!(f, "FalErrorPlus::AnyhowError: {:?}", err),
       Self::UrlParseError(err) => write!(f, "FalErrorPlus::UrlParseError: {:?}", err),
       Self::UnhandledEndpoint(endpoint) => write!(f, "FalErrorPlus::UnhandledEndpoint: {:?}", endpoint),
+      Self::ReqwestError(err) => write!(f, "FalErrorPlus::ReqwestError: {:?}", err),
     }
   }
 }
@@ -48,3 +51,9 @@ impl From<url::ParseError> for FalErrorPlus {
     FalErrorPlus::UrlParseError(err)
   }
 }
+
+impl From<reqwest::Error> for FalErrorPlus {
+  fn from(err: reqwest::Error) -> Self {
+    FalErrorPlus::ReqwestError(err)
+  }
+}

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

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

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

@@ -1,4 +1,2 @@
-pub mod enqueue_hunyuan2_image_to_3d;
-pub mod remove_background_rembg;
-pub mod video_gen;
-pub mod image_gen;
+pub mod queue;
+pub mod webhook;

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

@@ -42,7 +42,7 @@ pub async fn enqueue_hunyuan2_image_to_3d<P: AsRef<Path>>(args: Hunyuan2Args<'_,
 #[cfg(test)]
 mod tests {
   use crate::creds::fal_api_key::FalApiKey;
-  use crate::requests::enqueue_hunyuan2_image_to_3d::{enqueue_hunyuan2_image_to_3d, Hunyuan2Args};
+  use crate::requests::queue::enqueue_hunyuan2_image_to_3d::{enqueue_hunyuan2_image_to_3d, Hunyuan2Args};
   use errors::AnyhowResult;
   use std::fs::read_to_string;
   use testing::test_file_path::test_file_path;

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::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/enqueue_recraft3_text_to_image.rs

@@ -39,7 +39,7 @@ pub async fn enqueue_recraft3_text_to_image(args: Recraft3TextToImageArgs<'_>) -
 #[cfg(test)]
 mod tests {
   use crate::creds::fal_api_key::FalApiKey;
-  use crate::requests::image_gen::enqueue_recraft3_text_to_image::{enqueue_recraft3_text_to_image, Recraft3TextToImageArgs};
+  use crate::requests::queue::image_gen::enqueue_recraft3_text_to_image::{enqueue_recraft3_text_to_image, Recraft3TextToImageArgs};
   use errors::AnyhowResult;
   use std::fs::read_to_string;
 

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

@@ -0,0 +1,2 @@
+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/mod.rs

@@ -0,0 +1,4 @@
+pub mod enqueue_hunyuan2_image_to_3d;
+pub mod image_gen;
+pub mod remove_background_rembg;
+pub mod video_gen;

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

@@ -9,11 +9,6 @@ use futures::StreamExt;
 use std::path::Path;
 use url::Url;
 
-pub struct RemBgArgs<'a, P: AsRef<Path>> {
-  pub image_path: P,
-  pub api_key: &'a FalApiKey,
-}
-
 pub struct RemBgResponse {
   pub image_url: Url,
 }
@@ -27,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()
@@ -59,8 +54,9 @@ pub async fn remove_background_rembg<P: AsRef<Path>>(image_path: P, api_key: &Fa
 #[cfg(test)]
 mod tests {
   use crate::creds::fal_api_key::FalApiKey;
-  use crate::requests::remove_background_rembg::remove_background_rembg;
+  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]
@@ -68,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::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/enqueue_minimax_01_image_to_video.rs

@@ -3,7 +3,6 @@ use crate::error::classify_fal_error::classify_fal_error;
 use crate::error::fal_error_plus::FalErrorPlus;
 use crate::model::enqueued_request::EnqueuedRequest;
 use fal::endpoints::fal_ai::minimax::image_to_video::image_to_video;
-use fal::endpoints::fal_ai::minimax::image_to_video::VideoOutput;
 use fal::endpoints::fal_ai::minimax::image_to_video::ImageToVideoRequest;
 use fal_client::file_to_base64_url::file_to_base64_url;
 use futures::StreamExt;
@@ -41,10 +40,10 @@ pub async fn enqueue_minimax_01_image_to_video<P: AsRef<Path>>(args: Minimax01Ar
 #[cfg(test)]
 mod tests {
   use crate::creds::fal_api_key::FalApiKey;
+  use crate::requests::queue::video_gen::enqueue_minimax_01_image_to_video::{enqueue_minimax_01_image_to_video, Minimax01Args};
   use errors::AnyhowResult;
   use std::fs::read_to_string;
   use testing::test_file_path::test_file_path;
-  use crate::requests::video_gen::enqueue_minimax_01_image_to_video::{enqueue_minimax_01_image_to_video, Minimax01Args};
 
   #[tokio::test]
   #[ignore]

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

@@ -0,0 +1,2 @@
+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/video_gen/mod.rs

@@ -1,2 +0,0 @@
-pub mod enqueue_kling_16_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,74 @@
+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, AspectRatioProperty, 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 aspect_ratio: FluxPro11UltraAspectRatio,
+  pub num_images: FluxPro11UltraNumImages,
+}
+
+#[derive(Copy, Clone, Debug)]
+pub enum FluxPro11UltraAspectRatio {
+  Square, // 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 FluxPro11UltraNumImages {
+  One, // Default
+  Two,
+  Three,
+  Four,
+}
+
+pub async fn enqueue_flux_pro_11_ultra_text_to_image_webhook<U: IntoUrl>(
+  args: FluxPro11UltraArgs<'_, U>
+) -> Result<WebhookResponse, FalErrorPlus> {
+  
+  let num_images = match args.num_images {
+    FluxPro11UltraNumImages::One => 1,
+    FluxPro11UltraNumImages::Two => 2,
+    FluxPro11UltraNumImages::Three => 3,
+    FluxPro11UltraNumImages::Four => 4,
+  };
+
+  let aspect_ratio = match args.aspect_ratio {
+    FluxPro11UltraAspectRatio::Square => AspectRatioProperty::Property_1_1,
+    FluxPro11UltraAspectRatio::LandscapeFourByThree => AspectRatioProperty::Property_4_3,
+    FluxPro11UltraAspectRatio::LandscapeSixteenByNine => AspectRatioProperty::Property_16_9,
+    FluxPro11UltraAspectRatio::PortraitThreeByFour => AspectRatioProperty::Property_3_4,
+    FluxPro11UltraAspectRatio::PortraitNineBySixteen => AspectRatioProperty::Property_9_16,
+  };
+  
+  let request = FluxProUltraTextToImageInput {
+    prompt: args.prompt.to_string(),
+    num_images: Some(num_images),
+    aspect_ratio: Some(aspect_ratio),
+    // Maybe expose
+    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

@@ -0,0 +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/image/remove_background_rembg_webhook.rs

@@ -0,0 +1,62 @@
+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::imageutils::rembg::{rembg, RemoveBackgroundInput};
+use fal::webhook::WebhookResponse;
+use reqwest::IntoUrl;
+
+pub struct RemoveBackgroundRembgWebhookArgs<'a, U: IntoUrl, V: IntoUrl> {
+  pub image_url: U, 
+  pub webhook_url: V,
+  pub api_key: &'a FalApiKey
+}
+
+pub async fn remove_background_rembg_webhook<U: IntoUrl, V: IntoUrl>(
+  args: RemoveBackgroundRembgWebhookArgs<'_, U, V>
+) -> Result<WebhookResponse, FalErrorPlus> {
+
+  let image_url = args.image_url.into_url()?;
+  
+  let request = RemoveBackgroundInput {
+    image_url: image_url.to_string(),
+    crop_to_bbox: None,
+    sync_mode: None
+  };
+
+  let result = rembg(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::remove_background_rembg_webhook::remove_background_rembg_webhook;
+  use crate::requests::webhook::image::remove_background_rembg_webhook::RemoveBackgroundRembgWebhookArgs;
+  use std::fs::read_to_string;
+
+  #[tokio::test]
+  #[ignore] // NB: Manually test, don't run in CI!
+  async fn test_rembg_request() -> anyhow::Result<()> {
+    // XXX: Don't commit secrets!
+    let api_key = read_to_string("/Users/bt/Artcraft/credentials/fal_api_key.txt")?;
+    let api_key = FalApiKey::from_str(&api_key);
+    
+    let args = RemoveBackgroundRembgWebhookArgs {
+      image_url: "https://cdn-2.fakeyou.com/media/b/2/p/b/0/b2pb09bcbxdqjzgbnsapvfs1t897wdnx/image_b2pb09bcbxdqjzgbnsapvfs1t897wdnx.png",
+      webhook_url: "https://api.storyteller.ai/webhook",
+      api_key: &api_key,
+    };
+    
+    let response = remove_background_rembg_webhook(args).await?;
+
+    println!("{:?}", response);
+
+    assert_eq!(1, 2);
+    
+    Ok(())
+  }
+}

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

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

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

@@ -0,0 +1,35 @@
+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::hunyuan3d::v2::{v2, Hunyuan3DInput};
+use fal::webhook::WebhookResponse;
+use reqwest::IntoUrl;
+
+pub struct Hunyuan3d2Args<'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_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();
+
+  let request = Hunyuan3DInput {
+    input_image_url: image_url,
+    textured_mesh: Some(true),
+    guidance_scale: None,
+    num_inference_steps: None,
+    octree_resolution: None,
+    seed: None,
+  };
+
+  let result = v2(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/object/mod.rs

@@ -0,0 +1,2 @@
+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

@@ -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::v1_6::pro::image_to_video::{image_to_video, ProImageToVideoRequest};
+use fal::webhook::WebhookResponse;
+use reqwest::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)]
+pub enum Kling16Duration {
+  Default,
+  FiveSeconds,
+  TenSeconds,
+}
+
+#[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,
+    Kling16Duration::FiveSeconds => Some("5".to_string()), // Gross...
+    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,
+    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_16_image_to_video_webhook::{enqueue_kling_16_image_to_video_webhook, Kling16Args, Kling16Duration};
+  use errors::AnyhowResult;
+  use std::fs::read_to_string;
+  use testing::test_file_path::test_file_path;
+
+  #[tokio::test]
+  #[ignore]
+  async fn test_kling16_video() -> AnyhowResult<()> {
+    let image = test_file_path("test_data/image/juno.jpg")?;
+
+    // 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 = Kling16Args {
+      image_path: image,
+      prompt: "a corgi looks out over the water",
+      api_key: &api_key,
+      duration: Kling16Duration::Default,
+    };
+
+    let result = enqueue_kling_16_image_to_video_webhook(args).await?;
+
+    Ok(())
+  }
+}
+*/

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

@@ -0,0 +1,5 @@
+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/openai_sora_client/src/requests/image_gen/image_gen_status.rs

@@ -6,9 +6,10 @@ use reqwest::Url;
 use serde_derive::{Deserialize, Serialize};
 use std::fmt::{Debug, Display};
 use std::{fs::File, io::Write, path::Path};
-use log::{debug, warn};
+use log::{debug, error, warn};
 use crate::creds::sora_credential_set::SoraCredentialSet;
 use crate::creds::sora_jwt_bearer_token::SoraJwtBearerToken;
+use crate::utils::classify_general_http_status_code_and_body::classify_general_http_status_code_and_body;
 
 const SORA_STATUS_URL: &str = "https://sora.com/backend/video_gen";
 
@@ -241,9 +242,10 @@ pub async fn get_image_gen_status(status_request: &StatusRequest, credentials: &
 
   debug!("response_body: {}", response_body);
 
-  if status != reqwest::StatusCode::OK {
-    // TODO: Handle non-200 status codes, esp. JWT errors and credential errors
-    return Err(SoraError::AnyhowError(anyhow::anyhow!("The physical status request failed; status = {:?}, message = {:?}", status, response_body)));
+  if !status.is_success() {
+    error!("The sora status request failed; status = {:?} ; response body = {}", status, response_body);
+    let error = classify_general_http_status_code_and_body(status, &response_body).await;
+    return Err(error);
   }
 
   let maybe_response = serde_json::from_str::<VideoGenStatusResponse>(response_body);

crates/lib/api_clients/storyteller_client/Cargo.toml

@@ -17,6 +17,7 @@ path = "src/lib.rs"
 workspace-build-acceleration = { workspace =  true }
 
 # Internal
+artcraft_api_defs = { workspace = true }
 enums = { workspace = true }
 enums_public = { workspace = true }
 errors = { workspace = true }

crates/lib/api_clients/storyteller_client/src/error/client_error.rs

@@ -2,6 +2,7 @@ use std::error::Error;
 use std::fmt::{Display, Formatter};
 use std::io;
 use std::path::PathBuf;
+use crate::error::api_error::ApiError;
 
 /// An error arising from the client, either before or after the request is sent.
 #[derive(Debug)]
@@ -14,6 +15,12 @@ pub enum ClientError {
 
   /// An error doing file I/O (on our side)
   IoError(io::Error),
+
+  /// An error setting up the client
+  ReqwestError(reqwest::Error),
+  
+  /// A serialization error with the request.
+  SerializationError(serde_json::Error),
 }
 
 impl Error for ClientError {}
@@ -24,6 +31,8 @@ impl Display for ClientError {
       Self::FileTypeNotKnown(path) => write!(f, "Could not determine the filetype for the file: {:?}", path),
       Self::FileTypeNotHandled(path) => write!(f, "Could not handle the file type for the file: {:?}", path),
       Self::IoError(err) => write!(f, "IO error: {}", err),
+      Self::ReqwestError(err) => write!(f, "Reqwest client error: {}", err),
+      Self::SerializationError(err) => write!(f, "Request serialization error: {}", err),
     }
   }
 }
@@ -33,3 +42,15 @@ impl From<io::Error> for ClientError {
     ClientError::IoError(error)
   }
 }
+
+impl From<serde_json::Error> for ClientError {
+  fn from(error: serde_json::Error) -> Self {
+    ClientError::SerializationError(error)
+  }
+}
+
+impl From<reqwest::Error> for ClientError {
+  fn from(error: reqwest::Error) -> Self {
+    ClientError::ReqwestError(error)
+  }
+}

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

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

crates/lib/api_clients/storyteller_client/src/generate/object/generate_hunyuan2_image_to_3d.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::object::generate_hunyuan_2_image_to_3d::{GenerateHunyuan2ImageTo3dRequest, GenerateHunyuan2ImageTo3dResponse, GENERATE_HUNYUAN_2_IMAGE_TO_3D_URL_PATH};
+use log::{debug, info};
+use reqwest::Client;
+
+pub async fn generate_hunyuan2_image_to_3d(
+  api_host: &ApiHost,
+  maybe_creds: Option<&StorytellerCredentialSet>,
+  request: GenerateHunyuan2ImageTo3dRequest,
+) -> Result<GenerateHunyuan2ImageTo3dResponse, 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_HUNYUAN_2_IMAGE_TO_3D_URL_PATH)
+}

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

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

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/lib.rs

@@ -2,6 +2,7 @@
 
 pub mod credentials;
 pub mod error;
+pub mod generate;
 pub mod media_files;
 pub mod recipes;
 pub mod shared_response_types;

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/lib/deprecated/http_server_common/src/response/response_success_helpers.rs

@@ -1,10 +1,17 @@
 use actix_web::HttpResponse;
+use actix_web::web::Json;
 
 #[derive(Serialize)]
 pub struct SimpleGenericJsonSuccess {
   pub success: bool,
 }
 
+impl SimpleGenericJsonSuccess {
+  pub fn wrapped(success: bool) -> Json<Self> {
+    Json(SimpleGenericJsonSuccess { success })
+  }
+}
+
 pub fn simple_json_success() -> HttpResponse {
   let response = SimpleGenericJsonSuccess {
     success: true,

crates/schema/database/mysql_queries/src/queries/generic_inference/fal/get_inference_job_by_fal_id.rs

@@ -0,0 +1,133 @@
+use anyhow::anyhow;
+use chrono::{DateTime, NaiveDateTime, TimeZone, Utc};
+use log::warn;
+use sqlx::pool::PoolConnection;
+use sqlx::{MySql, MySqlPool};
+
+use enums::by_table::generic_inference_jobs::frontend_failure_category::FrontendFailureCategory;
+use enums::by_table::generic_inference_jobs::inference_category::InferenceCategory;
+use enums::by_table::generic_inference_jobs::inference_job_external_third_party::InferenceJobExternalThirdParty;
+use enums::by_table::generic_inference_jobs::inference_job_product_category::InferenceJobProductCategory;
+use enums::common::job_status_plus::JobStatusPlus;
+use enums::no_table::style_transfer::style_transfer_name::StyleTransferName;
+use errors::AnyhowResult;
+use tokens::tokens::anonymous_visitor_tracking::AnonymousVisitorTrackingToken;
+use tokens::tokens::generic_inference_jobs::InferenceJobToken;
+use tokens::tokens::users::UserToken;
+
+use crate::helpers::boolean_converters::i8_to_bool;
+use crate::payloads::generic_inference_args::generic_inference_args::{GenericInferenceArgs, PolymorphicInferenceArgs};
+
+#[derive(Debug, Default)]
+pub struct FalJobDetails {
+  pub job_token: InferenceJobToken,
+
+  pub status: JobStatusPlus,
+
+  pub external_third_party: InferenceJobExternalThirdParty,
+  pub external_third_party_id: String,
+
+  pub maybe_creator_user_token: Option<UserToken>,
+  pub maybe_creator_anonymous_visitor_token: Option<AnonymousVisitorTrackingToken>,
+  pub creator_ip_address: String,
+
+  pub created_at: DateTime<Utc>,
+  pub updated_at: DateTime<Utc>,
+}
+
+/// Returns Ok(None) when the record cannot be found.
+pub async fn get_inference_job_by_fal_id(fal_id: &str, mysql_pool: &MySqlPool)
+  -> AnyhowResult<Option<FalJobDetails>>
+{
+  let mut connection = mysql_pool.acquire().await?;
+  get_inference_job_by_fal_id_from_connection(fal_id, &mut connection).await
+}
+
+
+/// Returns Ok(None) when the record cannot be found.
+pub async fn get_inference_job_by_fal_id_from_connection(fal_id: &str, mysql_connection: &mut PoolConnection<MySql>)
+  -> AnyhowResult<Option<FalJobDetails>>
+{
+  // NB(bt): jobs.uuid_idempotency_token is the current way to reconstruct the hash of the
+  // TTS result since we don't store a bucket hash on the table. This is an ugly hack :(
+  // TODO(bt,2023-10-12): ^^^ Is this comment still accurate? I don't see that field referenced below.
+
+  let maybe_status = sqlx::query_as!(
+      RawJobRecord,
+        r#"
+SELECT
+    jobs.token as `job_token: tokens::tokens::generic_inference_jobs::InferenceJobToken`,
+
+    jobs.status as `status: enums::common::job_status_plus::JobStatusPlus`,
+    
+    jobs.maybe_external_third_party as `external_third_party: enums::by_table::generic_inference_jobs::inference_job_external_third_party::InferenceJobExternalThirdParty`,
+    jobs.maybe_external_third_party_id as `external_third_party_id`,
+
+    jobs.maybe_creator_user_token as `maybe_creator_user_token: tokens::tokens::users::UserToken`,
+    jobs.maybe_creator_anonymous_visitor_token as `maybe_creator_anonymous_visitor_token: tokens::tokens::anonymous_visitor_tracking::AnonymousVisitorTrackingToken`,
+    jobs.creator_ip_address,
+
+    jobs.created_at,
+    jobs.updated_at
+
+FROM generic_inference_jobs as jobs
+
+WHERE jobs.maybe_external_third_party = ?
+AND jobs.maybe_external_third_party_id = ?
+        "#,
+      InferenceJobExternalThirdParty::Fal.to_str(),
+      fal_id
+    )
+      .fetch_one(&mut **mysql_connection)
+      .await;
+
+  let record = match maybe_status {
+    Ok(record) => record,
+    Err(err) => match err {
+      sqlx::Error::RowNotFound => return Ok(None),
+      _ => {
+        warn!("error querying job record: {:?}", err);
+        return Err(anyhow!("error querying job record: {:?}", err));
+      }
+    }
+  };
+
+  let record = raw_record_to_public_result(record)?;
+  
+  Ok(Some(record))
+}
+
+fn raw_record_to_public_result(record: RawJobRecord) -> AnyhowResult<FalJobDetails> {
+  Ok(FalJobDetails {
+    job_token: record.job_token,
+    status: record.status,
+    external_third_party: record.external_third_party.ok_or_else(|| anyhow!("missing external_third_party"))?,
+    external_third_party_id: record.external_third_party_id.ok_or_else(|| anyhow!("missing external_third_party_id"))?,
+    maybe_creator_user_token: record.maybe_creator_user_token,
+    maybe_creator_anonymous_visitor_token: record.maybe_creator_anonymous_visitor_token,
+    creator_ip_address: record.creator_ip_address,
+    created_at: record.created_at,
+    updated_at: record.updated_at,
+  })
+}
+
+#[derive(Debug, Default)]
+struct RawJobRecord {
+  pub job_token: InferenceJobToken,
+
+  pub status: JobStatusPlus,
+
+  // NB: Nullable, but required to be filled for this query
+  pub external_third_party: Option<InferenceJobExternalThirdParty>,
+  
+  // NB: Nullable, but required to be filled for this query
+  pub external_third_party_id: Option<String>,
+
+  pub maybe_creator_user_token: Option<UserToken>,
+  pub maybe_creator_anonymous_visitor_token: Option<AnonymousVisitorTrackingToken>,
+  pub creator_ip_address: String,
+
+  pub created_at: DateTime<Utc>,
+  pub updated_at: DateTime<Utc>,
+}
+

crates/schema/database/mysql_queries/src/queries/generic_inference/fal/insert_generic_inference_job_for_fal_queue.rs

@@ -0,0 +1,159 @@
+use anyhow::anyhow;
+use log::info;
+use sqlx::MySqlPool;
+
+use enums::by_table::generic_inference_jobs::inference_category::InferenceCategory;
+use enums::by_table::generic_inference_jobs::inference_input_source_token_type::InferenceInputSourceTokenType;
+use enums::by_table::generic_inference_jobs::inference_job_external_third_party::InferenceJobExternalThirdParty;
+use enums::by_table::generic_inference_jobs::inference_job_product_category::InferenceJobProductCategory;
+use enums::by_table::generic_inference_jobs::inference_job_type::InferenceJobType;
+use enums::by_table::generic_inference_jobs::inference_model_type::InferenceModelType;
+use enums::common::job_status_plus::JobStatusPlus;
+use enums::common::visibility::Visibility;
+use tokens::tokens::anonymous_visitor_tracking::AnonymousVisitorTrackingToken;
+use tokens::tokens::generic_inference_jobs::InferenceJobToken;
+use tokens::tokens::media_files::MediaFileToken;
+use tokens::tokens::users::UserToken;
+
+use crate::errors::database_query_error::DatabaseQueryError;
+use crate::payloads::generic_inference_args::generic_inference_args::GenericInferenceArgs;
+use crate::queries::tts::tts_inference_jobs::kill_tts_inference_jobs::JobStatus;
+
+#[derive(Debug, Clone, Copy)]
+pub enum FalCategory {
+  ImageGeneration,
+  VideoGeneration,
+  BackgroundRemoval,
+  ObjectGeneration,
+}
+
+pub struct InsertGenericInferenceForFalArgs<'a> {
+  pub uuid_idempotency_token: &'a str,
+
+  /// The external primary key identifier for the job.
+  pub maybe_external_third_party_id: &'a str,
+  
+  pub fal_category: FalCategory,
+
+  pub maybe_inference_args: Option<GenericInferenceArgs>,
+
+  pub maybe_creator_user_token: Option<&'a UserToken>,
+  pub maybe_avt_token: Option<&'a AnonymousVisitorTrackingToken>,
+  pub creator_ip_address: &'a str,
+  pub creator_set_visibility: Visibility,
+
+  pub mysql_pool: &'a MySqlPool,
+}
+
+pub async fn insert_generic_inference_job_for_fal_queue(args: InsertGenericInferenceForFalArgs<'_>)
+  -> Result<InferenceJobToken, DatabaseQueryError>
+{
+  let job_token = InferenceJobToken::generate();
+
+  let serialized_args_payload = serde_json::ser::to_string(&args.maybe_inference_args)
+      .map_err(|_e| anyhow!("could not encode inference args"))?;
+
+
+  const JOB_TYPE : InferenceJobType = InferenceJobType::FalQueue;
+
+  let (inference_category, product_category) =
+      match args.fal_category {
+        FalCategory::ImageGeneration => (
+          InferenceCategory::ImageGeneration,
+          InferenceJobProductCategory::FalImage
+        ),
+        FalCategory::VideoGeneration => (
+          InferenceCategory::VideoGeneration,
+          InferenceJobProductCategory::FalVideo
+        ),
+        FalCategory::BackgroundRemoval => (
+          InferenceCategory::BackgroundRemoval,
+          InferenceJobProductCategory::FalBgRemoval
+        ),
+        FalCategory::ObjectGeneration => (
+          InferenceCategory::ObjectGeneration,
+          InferenceJobProductCategory::FalObject,
+        ),
+      };
+
+
+  let maybe_external_third_party = InferenceJobExternalThirdParty::Fal;
+  
+  let maybe_external_third_party_id = "";
+  const STATUS : JobStatusPlus = JobStatusPlus::Pending;
+
+  let query = sqlx::query!(
+        r#"
+INSERT INTO generic_inference_jobs
+SET
+  token = ?,
+  uuid_idempotency_token = ?,
+
+  job_type = ?,
+
+  maybe_external_third_party = ?,
+  maybe_external_third_party_id = ?,
+
+  product_category = ?,
+  inference_category = ?,
+
+  maybe_model_type = NULL,
+  maybe_model_token = NULL,
+
+  maybe_input_source_token = NULL,
+  maybe_input_source_token_type = NULL,
+
+  maybe_download_url = NULL,
+  maybe_cover_image_media_file_token = NULL,
+
+  maybe_raw_inference_text = NULL,
+
+  maybe_inference_args = ?,
+
+  maybe_creator_user_token = ?,
+  maybe_creator_anonymous_visitor_token = ?,
+  creator_ip_address = ?,
+  creator_set_visibility = ?,
+
+  priority_level = 0,
+  is_keepalive_required = FALSE,
+  max_duration_seconds = 0,
+
+  is_debug_request = FALSE,
+  maybe_routing_tag = NULL,
+
+  status = ?
+        "#,
+        job_token.as_str(),
+        args.uuid_idempotency_token,
+
+        JOB_TYPE.to_str(),
+    
+        maybe_external_third_party.to_str(),
+        args.maybe_external_third_party_id,
+
+        product_category.to_str(),
+        inference_category.to_str(),
+
+        serialized_args_payload,
+
+        args.maybe_creator_user_token.map(|t| t.to_string()),
+        args.maybe_avt_token.map(|t| t.to_string()),
+        args.creator_ip_address,
+        args.creator_set_visibility.to_str(),
+
+        STATUS.to_str(),
+    );
+
+  let query_result = query.execute(args.mysql_pool)
+      .await;
+
+  let record_id = match query_result {
+    Err(err) => return Err(DatabaseQueryError::from(err)),
+    Ok(res) => res.last_insert_id(),
+  };
+
+  info!("Insert generic inference job for FAL queue: {job_token} with record ID {record_id}");
+
+  Ok(job_token)
+}

crates/schema/database/mysql_queries/src/queries/generic_inference/fal/mark_fal_generic_inference_job_successfully_done.rs

@@ -0,0 +1,48 @@
+use anyhow::anyhow;
+use sqlx::MySqlPool;
+
+use enums::by_table::generic_inference_jobs::inference_result_type::InferenceResultType;
+use enums::common::job_status_plus::JobStatusPlus;
+use errors::AnyhowResult;
+use tokens::tokens::generic_inference_jobs::InferenceJobToken;
+use tokens::tokens::media_files::MediaFileToken;
+
+// TODO: Maybe in the future we set a batch_token instead of media token
+
+pub async fn mark_fal_generic_inference_job_successfully_done(
+  pool: &MySqlPool,
+  job_token: &InferenceJobToken,
+  media_file_token: MediaFileToken,
+) -> AnyhowResult<()>
+{
+  const STATUS : JobStatusPlus = JobStatusPlus::CompleteSuccess;
+  const RESULT_TYPE : InferenceResultType = InferenceResultType::MediaFile;
+
+  let query_result = sqlx::query!(
+        r#"
+UPDATE generic_inference_jobs
+SET
+  status = ?,
+  on_success_result_entity_type = ?,
+  on_success_result_entity_token = ?,
+  failure_reason = NULL,
+  internal_debugging_failure_reason = NULL,
+  success_execution_millis = NULL,
+  success_inference_execution_millis = NULL,
+  retry_at = NULL,
+  successfully_completed_at = NOW()
+WHERE token = ?
+        "#,
+        STATUS.to_str(),
+        RESULT_TYPE.to_str(),
+        media_file_token,
+        job_token,
+    )
+      .execute(pool)
+      .await;
+
+  match query_result {
+    Err(err) => Err(anyhow!("error with query: {:?}", err)),
+    Ok(_r) => Ok(()),
+  }
+}

crates/schema/database/mysql_queries/src/queries/generic_inference/fal/mod.rs

@@ -0,0 +1,3 @@
+pub mod get_inference_job_by_fal_id;
+pub mod insert_generic_inference_job_for_fal_queue;
+pub mod mark_fal_generic_inference_job_successfully_done;

crates/schema/database/mysql_queries/src/queries/generic_inference/mod.rs

@@ -1,2 +1,3 @@
+pub mod fal;
 pub mod job;
 pub mod web;

crates/schema/database/mysql_queries/src/queries/generic_inference/web/batch_get_inference_job_status.rs

@@ -174,6 +174,9 @@ fn raw_records_to_public_result(records: Vec<RawGenericInferenceJobStatus>) -> V
             InferenceCategory::VoiceConversion => record.maybe_voice_conversion_model_title.as_deref(),
             InferenceCategory::VideoFilter => Some("Video Filter"),
             InferenceCategory::ImageGeneration => Some("Image Generation"),
+            InferenceCategory::VideoGeneration => Some("Video Generation"),
+            InferenceCategory::ObjectGeneration => Some("Object Generation"),
+            InferenceCategory::BackgroundRemoval => Some("Background Removal"),
             InferenceCategory::Mocap => Some("Mocap"),
             InferenceCategory::Workflow => Some("Workflow"),
             InferenceCategory::FormatConversion => Some("format conversion"),
@@ -194,6 +197,9 @@ fn raw_records_to_public_result(records: Vec<RawGenericInferenceJobStatus>) -> V
           InferenceCategory::VoiceConversion => (true, record.maybe_voice_conversion_public_bucket_hash.as_deref()),
           InferenceCategory::VideoFilter => (true, record.maybe_media_file_public_bucket_directory_hash.as_deref()),
           InferenceCategory::ImageGeneration => (true, record.maybe_media_file_public_bucket_directory_hash.as_deref()),
+          InferenceCategory::VideoGeneration => (true, record.maybe_media_file_public_bucket_directory_hash.as_deref()),
+          InferenceCategory::ObjectGeneration => (true, record.maybe_media_file_public_bucket_directory_hash.as_deref()),
+          InferenceCategory::BackgroundRemoval => (true, record.maybe_media_file_public_bucket_directory_hash.as_deref()),
           InferenceCategory::Mocap => (true, record.maybe_media_file_public_bucket_directory_hash.as_deref()),
           InferenceCategory::Workflow => (true, record.maybe_media_file_public_bucket_directory_hash.as_deref()),
           InferenceCategory::FormatConversion => (true, record.maybe_media_file_public_bucket_directory_hash.as_deref()),

crates/schema/database/mysql_queries/src/queries/generic_inference/web/get_inference_job_status.rs

@@ -150,6 +150,9 @@ fn raw_record_to_public_result(record: RawGenericInferenceJobStatus) -> GenericI
       InferenceCategory::VoiceConversion => record.maybe_voice_conversion_model_title.as_deref(),
       InferenceCategory::VideoFilter => Some("Video Filter"),
       InferenceCategory::ImageGeneration => Some("Image Generation"),
+      InferenceCategory::VideoGeneration => Some("Video Generation"),
+      InferenceCategory::ObjectGeneration => Some("Object Generation"),
+      InferenceCategory::BackgroundRemoval => Some("Background Removal"),
       InferenceCategory::Mocap => Some("Mocap"),
       InferenceCategory::Workflow => Some("Workflow"),
       InferenceCategory::FormatConversion => Some("format conversion"),
@@ -170,6 +173,9 @@ fn raw_record_to_public_result(record: RawGenericInferenceJobStatus) -> GenericI
     InferenceCategory::VoiceConversion => (true, record.maybe_voice_conversion_public_bucket_hash.as_deref()),
     InferenceCategory::VideoFilter => (true, record.maybe_media_file_public_bucket_directory_hash.as_deref()),
     InferenceCategory::ImageGeneration => (true, record.maybe_media_file_public_bucket_directory_hash.as_deref()),
+    InferenceCategory::VideoGeneration => (true, record.maybe_media_file_public_bucket_directory_hash.as_deref()),
+    InferenceCategory::ObjectGeneration => (true, record.maybe_media_file_public_bucket_directory_hash.as_deref()),
+    InferenceCategory::BackgroundRemoval => (true, record.maybe_media_file_public_bucket_directory_hash.as_deref()),
     InferenceCategory::Mocap => (true, record.maybe_media_file_public_bucket_directory_hash.as_deref()),
     InferenceCategory::Workflow => (true, record.maybe_media_file_public_bucket_directory_hash.as_deref()),
     InferenceCategory::FormatConversion => (true, record.maybe_media_file_public_bucket_directory_hash.as_deref()),

crates/schema/database/mysql_queries/src/queries/generic_inference/web/list_session_jobs.rs

@@ -241,6 +241,9 @@ fn raw_records_to_public_result(records: Vec<RawGenericInferenceJobStatus>) -> V
             InferenceCategory::VoiceConversion => record.maybe_voice_conversion_model_title.as_deref(),
             InferenceCategory::VideoFilter => Some("Video Filter"),
             InferenceCategory::ImageGeneration => Some("Image Generation"),
+            InferenceCategory::VideoGeneration => Some("Video Generation"),
+            InferenceCategory::ObjectGeneration => Some("Object Generation"),
+            InferenceCategory::BackgroundRemoval => Some("Background Removal"),
             InferenceCategory::Mocap => Some("Mocap"),
             InferenceCategory::Workflow => Some("Workflow"),
             InferenceCategory::FormatConversion => Some("format conversion"),
@@ -260,6 +263,9 @@ fn raw_records_to_public_result(records: Vec<RawGenericInferenceJobStatus>) -> V
           InferenceCategory::VoiceConversion => (true, record.maybe_voice_conversion_public_bucket_hash.as_deref()),
           InferenceCategory::VideoFilter => (true, record.maybe_media_file_public_bucket_directory_hash.as_deref()),
           InferenceCategory::ImageGeneration => (true, record.maybe_media_file_public_bucket_directory_hash.as_deref()),
+          InferenceCategory::VideoGeneration => (true, record.maybe_media_file_public_bucket_directory_hash.as_deref()),
+          InferenceCategory::ObjectGeneration => (true, record.maybe_media_file_public_bucket_directory_hash.as_deref()),
+          InferenceCategory::BackgroundRemoval => (true, record.maybe_media_file_public_bucket_directory_hash.as_deref()),
           InferenceCategory::Mocap => (true, record.maybe_media_file_public_bucket_directory_hash.as_deref()),
           InferenceCategory::Workflow => (true, record.maybe_media_file_public_bucket_directory_hash.as_deref()),
           InferenceCategory::FormatConversion => (true, record.maybe_media_file_public_bucket_directory_hash.as_deref()),

crates/schema/database/mysql_queries/src/queries/media_files/create/generic_insert/insert_media_file_generic.rs

@@ -4,6 +4,7 @@ use sqlx::MySqlPool;
 
 use enums::by_table::generic_synthetic_ids::id_category::IdCategory;
 use enums::by_table::media_files::media_file_class::MediaFileClass;
+use enums::by_table::media_files::media_file_engine_category::MediaFileEngineCategory;
 use enums::by_table::media_files::media_file_origin_category::MediaFileOriginCategory;
 use enums::by_table::media_files::media_file_origin_model_type::MediaFileOriginModelType;
 use enums::by_table::media_files::media_file_origin_product_category::MediaFileOriginProductCategory;
@@ -51,6 +52,9 @@ pub struct InsertArgs<'a> {
     pub maybe_frame_width: Option<u32>,
     pub maybe_frame_height: Option<u32>,
     pub checksum_sha2: &'a str,
+    
+    // Media info for certain product areas
+    pub maybe_engine_category: Option<MediaFileEngineCategory>, // TODO: Deprecate
 
     // User text information
     pub maybe_title: Option<&'a str>,
@@ -152,6 +156,8 @@ pub async fn insert_media_file_generic(
             maybe_frame_height = ?,
             maybe_prompt_token = ?,
             checksum_sha2 = ?,
+            
+            maybe_engine_category = ?,
 
             maybe_title = ?,
             maybe_text_transcript = ?,
@@ -205,6 +211,8 @@ pub async fn insert_media_file_generic(
         args.maybe_prompt_token.map(|t| t.as_str()),
         args.checksum_sha2,
 
+        args.maybe_engine_category.map(|e| e.to_str()),
+
         args.maybe_title,
         args.maybe_text_transcript,
 

crates/schema/database/mysql_queries/src/queries/media_files/create/generic_insert/insert_media_file_generic_from_job.rs

@@ -107,6 +107,7 @@ pub async fn insert_media_file_generic_from_job(
         maybe_extra_media_info: args.maybe_extra_media_info,
         maybe_frame_height: args.maybe_frame_height,
         maybe_frame_width: args.maybe_frame_width,
+        maybe_engine_category: None,
         maybe_mime_type: args.maybe_mime_type,
         maybe_mod_user_token: args.maybe_mod_user_token,
         maybe_origin_filename: args.maybe_origin_filename,

crates/schema/database/mysql_queries/src/queries/media_files/create/insert_builder/media_file_insert_builder.rs

@@ -9,6 +9,7 @@ use enums::by_table::media_files::media_file_type::MediaFileType;
 use enums::common::visibility::Visibility;
 use errors::AnyhowResult;
 use sqlx::MySqlPool;
+use enums::by_table::media_files::media_file_engine_category::MediaFileEngineCategory;
 use tokens::tokens::anonymous_visitor_tracking::AnonymousVisitorTrackingToken;
 use tokens::tokens::media_files::MediaFileToken;
 use tokens::tokens::users::UserToken;
@@ -44,13 +45,16 @@ pub struct MediaFileInsertBuilder {
   // Media info
   maybe_mime_type: Option<String>,
   file_size_bytes: u64, // NB: Non-nullable field
-  // maybe_duration_millis: Option<u64>,
+  maybe_duration_millis: Option<u64>,
   // maybe_audio_encoding: Option<&'a str>,
   // maybe_video_encoding: Option<&'a str>,
   maybe_frame_width: Option<u32>,
   maybe_frame_height: Option<u32>,
   checksum_sha2: Option<String>, // NB: Non-nullable field
 
+  // Media info for certain product areas
+  pub maybe_engine_category: Option<MediaFileEngineCategory>, // TODO: Deprecate
+  
   // // User text information
   // maybe_title: Option<&'a str>,
   // maybe_text_transcript: Option<&'a str>,
@@ -90,9 +94,11 @@ impl MediaFileInsertBuilder {
       origin_product_category: MediaFileOriginProductCategory::Unknown,
       maybe_mime_type: None,
       file_size_bytes: 0,
+      maybe_duration_millis: None,
       maybe_frame_width: None,
       maybe_frame_height: None,
       checksum_sha2: None,
+      maybe_engine_category: None,
       public_bucket_directory_hash: None,
     }
   }
@@ -173,25 +179,44 @@ impl MediaFileInsertBuilder {
     self
   }
 
-  // TODO: maybe_duration_millis
+  pub fn maybe_duration_millis(mut self, maybe_duration_millis: Option<u64>) -> Self {
+    self.maybe_duration_millis = maybe_duration_millis;
+    self
+  }
+
   // TODO: maybe_audio_encoding
   // TODO: maybe_video_encoding
-
+  
   pub fn frame_width(mut self, frame_width: u32) -> Self {
     self.maybe_frame_width = Some(frame_width);
     self
   }
 
+  pub fn maybe_frame_width(mut self, maybe_frame_width: Option<u32>) -> Self {
+    self.maybe_frame_width = maybe_frame_width;
+    self
+  }
+
   pub fn frame_height(mut self, frame_height: u32) -> Self {
     self.maybe_frame_height = Some(frame_height);
     self
   }
+  
+  pub fn maybe_frame_height(mut self, maybe_frame_height: Option<u32>) -> Self {
+    self.maybe_frame_height = maybe_frame_height;
+    self
+  }
 
   pub fn checksum_sha2(mut self, checksum_sha2: &str) -> Self {
     self.checksum_sha2 = Some(checksum_sha2.to_string());
     self
   }
 
+  pub fn maybe_engine_category(mut self, maybe_engine_category: Option<MediaFileEngineCategory>) -> Self {
+    self.maybe_engine_category = maybe_engine_category;
+    self
+  }
+
   // TODO: maybe_title
   // TODO: maybe_text_transcript
   // TODO: maybe_scene_source_media_file_token
@@ -238,11 +263,12 @@ impl MediaFileInsertBuilder {
       maybe_origin_filename: None, // TODO
       maybe_mime_type: self.maybe_mime_type.as_deref(),
       file_size_bytes: self.file_size_bytes,
-      maybe_duration_millis: None, // TODO
+      maybe_duration_millis: self.maybe_duration_millis,
       maybe_audio_encoding: None, // TODO
       maybe_video_encoding: None, // TODO
       maybe_frame_width: self.maybe_frame_width,
       maybe_frame_height: self.maybe_frame_height,
+      maybe_engine_category: self.maybe_engine_category,
       checksum_sha2: &checksum_sha2,
       maybe_title: None, // TODO
       maybe_text_transcript: None, // TODO

crates/schema/database/mysql_queries/src/queries/media_files/create/insert_media_file_from_studio_scene_render.rs

@@ -111,6 +111,7 @@ pub async fn insert_media_file_from_studio_scene_render(
     maybe_batch_token: None,
     maybe_prompt_token: None,
     maybe_mod_user_token: None,
+    maybe_engine_category: None,
   }).await?;
 
   Ok(new_media_token)