special model handling

This commit is contained in:
Brandon Thomas committed 2026-05-03 05:10:01 -04:00
1 parent 9b69a92a87
commit a28325534d
6 files changed
+296 -74

No files matched your search

@@ -1,91 +1,45 @@
use artcraft_router::api::common_image_model::CommonImageModel;
use artcraft_router::api::image_list_ref::ImageListRef;
use artcraft_router::api::provider::Provider;
use artcraft_router::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
use artcraft_router::client::router_artcraft_client::RouterArtcraftClient;
use artcraft_router::client::router_client::RouterClient;
use artcraft_router::generate::generate_image::generate_image_request::GenerateImageRequest;
use enums::common::generation_provider::GenerationProvider;
use enums::tauri::tasks::task_type::TaskType;
use log::{error, info};
use artcraft_client::credentials::storyteller_credential_set::StorytellerCredentialSet;
use crate::core::commands::enqueue::generate_error::GenerateError;
use crate::core::commands::enqueue::task_enqueue_success::TaskEnqueueSuccess;
use crate::core::api_adapters::models::image::tauri_image_model_to_generation_model::tauri_image_model_to_generation_model;
use crate::core::api_adapters::models::image::tauri_image_model_to_router_model::tauri_image_model_to_router_model;
use crate::core::commands::generate::generate_image::providers::artcraft::legacy::artcraft_flux_2_lora_angles::handle_flux_2_lora_angles;
use crate::core::commands::generate::generate_image::providers::artcraft::legacy::artcraft_flux_dev_juggernaut_inpaint::handle_flux_dev_juggernaut_inpaint;
use crate::core::commands::generate::generate_image::providers::artcraft::legacy::artcraft_qwen_edit_2511_angles::handle_qwen_edit_2511_angles;
use crate::core::commands::generate::generate_image::tauri_generate_image_request::TauriGenerateImageRequest;
use crate::core::commands::generate::generate_image::tauri_image_model::TauriImageModel;
use crate::core::commands::generate::generate_image::utils::parse_semantic_media_files::SemanticMediaFiles;
use crate::core::state::app_env_configs::app_env_configs::AppEnvConfigs;
/// Handle image generation via the legacy artcraft_router path.
/// Handle image generation via legacy model-specific paths.
///
/// This is used for models not yet supported by the omni endpoint
/// (eg. Recraft, FluxProKontextMax, edit/inpaint models).
/// Dispatches to dedicated handlers for each supported legacy model.
pub async fn handle_artcraft_via_legacy(
request: &TauriGenerateImageRequest,
_semantic_media_files: &SemanticMediaFiles,
semantic_media_files: &SemanticMediaFiles,
creds: &StorytellerCredentialSet,
app_env_configs: &AppEnvConfigs,
) -> Result<TaskEnqueueSuccess, GenerateError> {
let model = request.model.ok_or(GenerateError::no_model_specified())?;
let router_model = tauri_image_model_to_router_model(model)
.ok_or(GenerateError::NotYetImplemented(
format!("Model {:?} is not supported via the legacy router path", model),
))?;
let generation_model = tauri_image_model_to_generation_model(model);
let client = RouterClient::Artcraft(RouterArtcraftClient::new(
app_env_configs.storyteller_host.clone(),
creds.clone(),
));
// Build image inputs: prepend canvas image if present.
let mut image_tokens = request.image_media_tokens.clone().unwrap_or_default();
if let Some(canvas_token) = &request.canvas_image_media_token {
image_tokens.insert(0, canvas_token.clone());
match model {
TauriImageModel::FluxDevJuggernaut => {
handle_flux_dev_juggernaut_inpaint(request, semantic_media_files, creds, app_env_configs).await
}
TauriImageModel::QwenEdit2511Angles => {
handle_qwen_edit_2511_angles(request, semantic_media_files, creds, app_env_configs).await
}
TauriImageModel::Flux2LoraAngles => {
handle_flux_2_lora_angles(request, semantic_media_files, creds, app_env_configs).await
}
TauriImageModel::Midjourney | TauriImageModel::Recraft3 => {
Err(GenerateError::NotYetImplemented(
format!("Model {:?} is not supported by provider Artcraft", model),
))
}
other => {
Err(GenerateError::NotYetImplemented(
format!("Model {:?} was incorrectly handled", other),
))
}
}
let image_inputs = if image_tokens.is_empty() { None } else { Some(ImageListRef::MediaFileTokens(image_tokens)) };
let router_request = GenerateImageRequest {
model: router_model,
provider: Provider::Artcraft,
prompt: request.prompt.clone(),
image_inputs,
resolution: None, // TODO: Convert from request.resolution
aspect_ratio: None, // TODO: Convert from request.aspect_ratio
quality: None, // TODO: Convert from request.quality
image_batch_count: request.batch_size.map(|n| n as u16),
request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::PayMoreUpgrade,
generation_mode_mismatch_strategy: None,
idempotency_token: None,
horizontal_angle: request.adjust_horizontal_angle,
vertical_angle: request.adjust_vertical_angle,
zoom: request.adjust_zoom,
};
let plan = router_request.build()?;
info!("Legacy image generation plan: {:?}", plan);
let response = plan.generate_image(&client).await.map_err(|err| {
error!("Legacy image generation failed: {:?}", err);
GenerateError::from(err)
})?;
let job_id = response
.get_artcraft_payload()
.map(|p| p.inference_job_token.to_string())
.ok_or(GenerateError::ResponseHadNoJobTokens)?;
info!("Legacy image generation succeeded: job_id={}", job_id);
Ok(TaskEnqueueSuccess {
task_type: TaskType::ImageGeneration,
model: Some(generation_model),
provider: GenerationProvider::Artcraft,
provider_job_id: Some(job_id),
})
}
@@ -0,0 +1,93 @@
use log::{error, info};
use artcraft_client::credentials::storyteller_credential_set::StorytellerCredentialSet;
use artcraft_router::api::common_image_model::CommonImageModel;
use artcraft_router::api::image_list_ref::ImageListRef;
use artcraft_router::api::provider::Provider;
use artcraft_router::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
use artcraft_router::client::router_artcraft_client::RouterArtcraftClient;
use artcraft_router::client::router_client::RouterClient;
use artcraft_router::generate::generate_image::generate_image_request::GenerateImageRequest;
use enums::common::generation_provider::GenerationProvider;
use enums::tauri::tasks::task_type::TaskType;
use crate::core::commands::enqueue::generate_error::GenerateError;
use crate::core::commands::enqueue::task_enqueue_success::TaskEnqueueSuccess;
use crate::core::commands::generate::generate_image::tauri_generate_image_request::TauriGenerateImageRequest;
use crate::core::commands::generate::generate_image::utils::parse_semantic_media_files::SemanticMediaFiles;
use crate::core::events::generation_events::common::GenerationModel;
use crate::core::state::app_env_configs::app_env_configs::AppEnvConfigs;
/// Handle Flux2LoraAngles image editing via the artcraft_router.
pub async fn handle_flux_2_lora_angles(
request: &TauriGenerateImageRequest,
semantic_media_files: &SemanticMediaFiles,
creds: &StorytellerCredentialSet,
app_env_configs: &AppEnvConfigs,
) -> Result<TaskEnqueueSuccess, GenerateError> {
let client = RouterClient::Artcraft(RouterArtcraftClient::new(
app_env_configs.storyteller_host.clone(),
creds.clone(),
));
let image_inputs = build_image_inputs(request, semantic_media_files);
let router_request = GenerateImageRequest {
model: CommonImageModel::Flux2LoraAngles,
provider: Provider::Artcraft,
prompt: request.prompt.clone(),
image_inputs,
resolution: None,
aspect_ratio: None,
quality: None,
image_batch_count: request.batch_size.map(|n| n as u16),
request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::PayMoreUpgrade,
generation_mode_mismatch_strategy: None,
idempotency_token: None,
horizontal_angle: request.adjust_horizontal_angle,
vertical_angle: request.adjust_vertical_angle,
zoom: request.adjust_zoom,
};
let plan = router_request.build()?;
info!("Flux2LoraAngles plan: {:?}", plan);
let response = plan.generate_image(&client).await.map_err(|err| {
error!("Flux2LoraAngles generation failed: {:?}", err);
GenerateError::from(err)
})?;
let job_id = response
.get_artcraft_payload()
.map(|p| p.inference_job_token.to_string())
.ok_or(GenerateError::ResponseHadNoJobTokens)?;
info!("Flux2LoraAngles succeeded: job_id={}", job_id);
Ok(TaskEnqueueSuccess {
task_type: TaskType::ImageGeneration,
model: Some(GenerationModel::Flux2LoraAngles),
provider: GenerationProvider::Artcraft,
provider_job_id: Some(job_id),
})
}
fn build_image_inputs(
request: &TauriGenerateImageRequest,
semantic_media_files: &SemanticMediaFiles,
) -> Option<ImageListRef> {
let mut tokens = Vec::new();
if let Some(scene_token) = &semantic_media_files.scene_image_media_token {
tokens.push(scene_token.clone());
}
if let Some(canvas_token) = &semantic_media_files.canvas_image_media_token {
tokens.push(canvas_token.clone());
}
if let Some(media_tokens) = &request.image_media_tokens {
tokens.extend(media_tokens.clone());
}
if tokens.is_empty() { None } else { Some(ImageListRef::MediaFileTokens(tokens)) }
}
@@ -0,0 +1,78 @@
use log::{error, info};
use artcraft_api_defs::generate::image::inpaint::flux_dev_juggernaut_inpaint_image::{
FluxDevJuggernautInpaintImageNumImages, FluxDevJuggernautInpaintImageRequest,
};
use artcraft_client::credentials::storyteller_credential_set::StorytellerCredentialSet;
use artcraft_client::endpoints::generate::image::inpaint::flux_dev_juggernaut_inpaint_image::flux_dev_juggernaut_inpaint_image;
use enums::common::generation_provider::GenerationProvider;
use enums::tauri::tasks::task_type::TaskType;
use uuid_utils::uuid::generate_random_uuid;
use crate::core::commands::enqueue::generate_error::{BadInputReason, GenerateError};
use crate::core::commands::enqueue::task_enqueue_success::TaskEnqueueSuccess;
use crate::core::commands::generate::generate_image::tauri_generate_image_request::TauriGenerateImageRequest;
use crate::core::commands::generate::generate_image::utils::parse_semantic_media_files::SemanticMediaFiles;
use crate::core::events::generation_events::common::GenerationModel;
use crate::core::state::app_env_configs::app_env_configs::AppEnvConfigs;
/// Handle FluxDevJuggernaut inpainting via the legacy dedicated endpoint.
///
/// Requires a canvas image (the source image to edit) and an inpainting mask.
pub async fn handle_flux_dev_juggernaut_inpaint(
request: &TauriGenerateImageRequest,
semantic_media_files: &SemanticMediaFiles,
creds: &StorytellerCredentialSet,
app_env_configs: &AppEnvConfigs,
) -> Result<TaskEnqueueSuccess, GenerateError> {
let image_media_token = semantic_media_files.canvas_image_media_token.clone()
.ok_or(GenerateError::required_source_image_not_provided())?;
let mask_media_token = semantic_media_files.inpainting_mask_image_media_token.clone()
.ok_or(GenerateError::required_source_image_mask_not_provided())?;
let num_images = match request.batch_size {
None => None,
Some(1) => Some(FluxDevJuggernautInpaintImageNumImages::One),
Some(2) => Some(FluxDevJuggernautInpaintImageNumImages::Two),
Some(3) => Some(FluxDevJuggernautInpaintImageNumImages::Three),
Some(4) => Some(FluxDevJuggernautInpaintImageNumImages::Four),
Some(other) => {
return Err(GenerateError::BadInput(BadInputReason::InvalidNumberOfRequestedImages {
min: 1,
max: 4,
requested: other,
}));
}
};
let uuid_idempotency_token = generate_random_uuid();
let inpaint_request = FluxDevJuggernautInpaintImageRequest {
uuid_idempotency_token,
prompt: request.prompt.clone(),
image_media_token,
mask_media_token,
num_images,
};
info!("Calling FluxDevJuggernaut inpaint...");
let response = flux_dev_juggernaut_inpaint_image(
&app_env_configs.storyteller_host,
Some(creds),
inpaint_request,
).await.map_err(|err| {
error!("FluxDevJuggernaut inpaint failed: {:?}", err);
GenerateError::from(err)
})?;
info!("FluxDevJuggernaut inpaint succeeded: job_token={}", response.inference_job_token);
Ok(TaskEnqueueSuccess {
task_type: TaskType::ImageInpaintEdit,
model: Some(GenerationModel::FluxDevJuggernaut),
provider: GenerationProvider::Artcraft,
provider_job_id: Some(response.inference_job_token.to_string()),
})
}
@@ -0,0 +1,93 @@
use log::{error, info};
use artcraft_client::credentials::storyteller_credential_set::StorytellerCredentialSet;
use artcraft_router::api::common_image_model::CommonImageModel;
use artcraft_router::api::image_list_ref::ImageListRef;
use artcraft_router::api::provider::Provider;
use artcraft_router::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
use artcraft_router::client::router_artcraft_client::RouterArtcraftClient;
use artcraft_router::client::router_client::RouterClient;
use artcraft_router::generate::generate_image::generate_image_request::GenerateImageRequest;
use enums::common::generation_provider::GenerationProvider;
use enums::tauri::tasks::task_type::TaskType;
use crate::core::commands::enqueue::generate_error::GenerateError;
use crate::core::commands::enqueue::task_enqueue_success::TaskEnqueueSuccess;
use crate::core::commands::generate::generate_image::tauri_generate_image_request::TauriGenerateImageRequest;
use crate::core::commands::generate::generate_image::utils::parse_semantic_media_files::SemanticMediaFiles;
use crate::core::events::generation_events::common::GenerationModel;
use crate::core::state::app_env_configs::app_env_configs::AppEnvConfigs;
/// Handle QwenEdit2511Angles image editing via the artcraft_router.
pub async fn handle_qwen_edit_2511_angles(
request: &TauriGenerateImageRequest,
semantic_media_files: &SemanticMediaFiles,
creds: &StorytellerCredentialSet,
app_env_configs: &AppEnvConfigs,
) -> Result<TaskEnqueueSuccess, GenerateError> {
let client = RouterClient::Artcraft(RouterArtcraftClient::new(
app_env_configs.storyteller_host.clone(),
creds.clone(),
));
let image_inputs = build_image_inputs(request, semantic_media_files);
let router_request = GenerateImageRequest {
model: CommonImageModel::QwenEdit2511Angles,
provider: Provider::Artcraft,
prompt: request.prompt.clone(),
image_inputs,
resolution: None,
aspect_ratio: None,
quality: None,
image_batch_count: request.batch_size.map(|n| n as u16),
request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::PayMoreUpgrade,
generation_mode_mismatch_strategy: None,
idempotency_token: None,
horizontal_angle: request.adjust_horizontal_angle,
vertical_angle: request.adjust_vertical_angle,
zoom: request.adjust_zoom,
};
let plan = router_request.build()?;
info!("QwenEdit2511Angles plan: {:?}", plan);
let response = plan.generate_image(&client).await.map_err(|err| {
error!("QwenEdit2511Angles generation failed: {:?}", err);
GenerateError::from(err)
})?;
let job_id = response
.get_artcraft_payload()
.map(|p| p.inference_job_token.to_string())
.ok_or(GenerateError::ResponseHadNoJobTokens)?;
info!("QwenEdit2511Angles succeeded: job_id={}", job_id);
Ok(TaskEnqueueSuccess {
task_type: TaskType::ImageGeneration,
model: Some(GenerationModel::QwenEdit2511Angles),
provider: GenerationProvider::Artcraft,
provider_job_id: Some(job_id),
})
}
fn build_image_inputs(
request: &TauriGenerateImageRequest,
semantic_media_files: &SemanticMediaFiles,
) -> Option<ImageListRef> {
let mut tokens = Vec::new();
if let Some(scene_token) = &semantic_media_files.scene_image_media_token {
tokens.push(scene_token.clone());
}
if let Some(canvas_token) = &semantic_media_files.canvas_image_media_token {
tokens.push(canvas_token.clone());
}
if let Some(media_tokens) = &request.image_media_tokens {
tokens.extend(media_tokens.clone());
}
if tokens.is_empty() { None } else { Some(ImageListRef::MediaFileTokens(tokens)) }
}
@@ -0,0 +1,3 @@
pub mod artcraft_flux_2_lora_angles;
pub mod artcraft_flux_dev_juggernaut_inpaint;
pub mod artcraft_qwen_edit_2511_angles;
@@ -1,5 +1,6 @@
mod handle_artcraft;
mod handle_artcraft_via_legacy;
mod handle_artcraft_via_omni_endpoint;
mod legacy;
pub use handle_artcraft::handle_artcraft;