stronger typing

This looks like a thick PR, because it is. 

We're going to do a lot with the middleware.

.gitignore

@@ -36,6 +36,7 @@ script/socat_dev_database_connect.sh
 venv/
 
 # Testing
+/prompts/
 /requests/
 
 # Scratch data

.sqlx/query-0757d81ba153b2ad2df25df3dd92b655ef08b95f5f83251bf3573f9be3a9f8d1.json

@@ -0,0 +1,102 @@
+{
+  "db_name": "MySQL",
+  "query": "\nSELECT\n    j.status as `job_status: enums::common::job_status_plus::JobStatusPlus`,\n    j.failure_reason as job_failure_reason,\n    wle.credits_delta,\n    wle.maybe_linked_refund_ledger_token as `maybe_linked_refund_ledger_token: tokens::tokens::wallet_ledger_entries::WalletLedgerEntryToken`,\n    j.on_success_result_entity_token as `on_success_result_media_token: tokens::tokens::media_files::MediaFileToken`,\n    j.token as `job_token: tokens::tokens::generic_inference_jobs::InferenceJobToken`,\n    wle.token as `wallet_ledger_entry_token: tokens::tokens::wallet_ledger_entries::WalletLedgerEntryToken`,\n    wle.entry_type as `wallet_ledger_entry_type: enums::by_table::wallet_ledger_entries::wallet_ledger_entry_type::WalletLedgerEntryType`\nFROM generic_inference_jobs as j\nLEFT OUTER JOIN users as u\n    ON j.maybe_creator_user_token = u.token\nLEFT OUTER JOIN wallet_ledger_entries as wle\n    ON wle.maybe_entity_ref = j.token\nWHERE u.token = ?\nORDER BY j.id DESC\n    ",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "job_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": 1,
+        "name": "job_failure_reason",
+        "type_info": {
+          "type": "VarString",
+          "flags": "BINARY",
+          "char_set": 224,
+          "max_size": 2048
+        }
+      },
+      {
+        "ordinal": 2,
+        "name": "credits_delta",
+        "type_info": {
+          "type": "Long",
+          "flags": "",
+          "char_set": 63,
+          "max_size": 11
+        }
+      },
+      {
+        "ordinal": 3,
+        "name": "maybe_linked_refund_ledger_token: tokens::tokens::wallet_ledger_entries::WalletLedgerEntryToken",
+        "type_info": {
+          "type": "VarString",
+          "flags": "BINARY",
+          "char_set": 224,
+          "max_size": 128
+        }
+      },
+      {
+        "ordinal": 4,
+        "name": "on_success_result_media_token: tokens::tokens::media_files::MediaFileToken",
+        "type_info": {
+          "type": "VarString",
+          "flags": "MULTIPLE_KEY | BINARY",
+          "char_set": 224,
+          "max_size": 128
+        }
+      },
+      {
+        "ordinal": 5,
+        "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": 6,
+        "name": "wallet_ledger_entry_token: tokens::tokens::wallet_ledger_entries::WalletLedgerEntryToken",
+        "type_info": {
+          "type": "VarString",
+          "flags": "UNIQUE_KEY | BINARY | NO_DEFAULT_VALUE",
+          "char_set": 224,
+          "max_size": 128
+        }
+      },
+      {
+        "ordinal": 7,
+        "name": "wallet_ledger_entry_type: enums::by_table::wallet_ledger_entries::wallet_ledger_entry_type::WalletLedgerEntryType",
+        "type_info": {
+          "type": "VarString",
+          "flags": "BINARY | NO_DEFAULT_VALUE",
+          "char_set": 224,
+          "max_size": 128
+        }
+      }
+    ],
+    "parameters": {
+      "Right": 1
+    },
+    "nullable": [
+      false,
+      true,
+      true,
+      true,
+      true,
+      false,
+      true,
+      true
+    ]
+  },
+  "hash": "0757d81ba153b2ad2df25df3dd92b655ef08b95f5f83251bf3573f9be3a9f8d1"
+}

.sqlx/query-08996721482fe897c2721298c04cf0eba5fcf1d04d57397b8afab3dd59feaa8c.json

@@ -1,12 +1,12 @@
 {
   "db_name": "MySQL",
-  "query": "\nINSERT INTO users\nSET\n  token = ?,\n  \n  is_temporary = ?,\n  \n  username = ?,\n  display_name = ?,\n\n  username_is_generated = ?,\n  username_is_not_customized = ?,\n\n  email_address = ?,\n  email_gravatar_hash = ?,\n\n  email_confirmed = FALSE,\n  email_confirmed_by_google = ?,\n  email_is_synthetic = ?,\n  \n  was_eagerly_provisioned = ?,\n\n  profile_markdown = ?,\n  profile_rendered_html = ?,\n  user_role_slug = ?,\n\n  password_hash = ?,\n  is_without_password = ?,\n\n  maybe_feature_flags = ?,\n\n  ip_address_creation = ?,\n  ip_address_last_login = ?,\n  ip_address_last_update = ?,\n\n  maybe_source = ?,\n\n  maybe_signup_method = ?\n        ",
+  "query": "\nINSERT INTO users\nSET\n  token = ?,\n  \n  is_temporary = ?,\n  \n  username = ?,\n  display_name = ?,\n\n  username_is_generated = ?,\n  username_is_not_customized = ?,\n\n  email_address = ?,\n  email_gravatar_hash = ?,\n\n  email_confirmed = FALSE,\n  email_confirmed_by_google = ?,\n  email_is_synthetic = ?,\n  \n  was_eagerly_provisioned = ?,\n\n  profile_markdown = ?,\n  profile_rendered_html = ?,\n  user_role_slug = ?,\n\n  password_hash = ?,\n  is_without_password = ?,\n\n  maybe_feature_flags = ?,\n\n  ip_address_creation = ?,\n  ip_address_last_login = ?,\n  ip_address_last_update = ?,\n\n  maybe_source = ?,\n\n  maybe_signup_method = ?,\n\n  maybe_referral_url = ?\n        ",
   "describe": {
     "columns": [],
     "parameters": {
-      "Right": 22
+      "Right": 23
     },
     "nullable": []
   },
-  "hash": "56746bcb993cb33f5492f401ce4fc3fd44d91fed660c2f106cb22e482dffa740"
+  "hash": "08996721482fe897c2721298c04cf0eba5fcf1d04d57397b8afab3dd59feaa8c"
 }

.sqlx/query-3390084f700ef2444691a02c691a59ccdd66bc8b096547e89c68b58b04dd44e4.json

@@ -0,0 +1,80 @@
+{
+  "db_name": "MySQL",
+  "query": "\nSELECT\n    user_subscriptions.subscription_namespace as `subscription_namespace: enums::common::payments_namespace::PaymentsNamespace`,\n    user_subscriptions.maybe_stripe_subscription_id,\n    users.token as `user_token: tokens::tokens::users::UserToken`,\n    users.email_address,\n    users.username,\n    users.display_name\nFROM user_subscriptions\nINNER JOIN users ON users.token = user_subscriptions.user_token\nWHERE\n    user_subscriptions.maybe_stripe_customer_id = ?\n    AND user_subscriptions.deleted_at IS NULL\n    AND users.user_deleted_at IS NULL\n    AND users.mod_deleted_at IS NULL\nORDER BY user_subscriptions.created_at DESC\n    ",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "subscription_namespace: enums::common::payments_namespace::PaymentsNamespace",
+        "type_info": {
+          "type": "VarString",
+          "flags": "NOT_NULL | MULTIPLE_KEY | BINARY | NO_DEFAULT_VALUE",
+          "char_set": 224,
+          "max_size": 128
+        }
+      },
+      {
+        "ordinal": 1,
+        "name": "maybe_stripe_subscription_id",
+        "type_info": {
+          "type": "VarString",
+          "flags": "UNIQUE_KEY | BINARY",
+          "char_set": 224,
+          "max_size": 1020
+        }
+      },
+      {
+        "ordinal": 2,
+        "name": "user_token: tokens::tokens::users::UserToken",
+        "type_info": {
+          "type": "VarString",
+          "flags": "NOT_NULL | UNIQUE_KEY | BINARY | NO_DEFAULT_VALUE",
+          "char_set": 224,
+          "max_size": 128
+        }
+      },
+      {
+        "ordinal": 3,
+        "name": "email_address",
+        "type_info": {
+          "type": "VarString",
+          "flags": "NOT_NULL | UNIQUE_KEY | BINARY | NO_DEFAULT_VALUE",
+          "char_set": 224,
+          "max_size": 1020
+        }
+      },
+      {
+        "ordinal": 4,
+        "name": "username",
+        "type_info": {
+          "type": "VarString",
+          "flags": "NOT_NULL | UNIQUE_KEY | BINARY | NO_DEFAULT_VALUE",
+          "char_set": 224,
+          "max_size": 80
+        }
+      },
+      {
+        "ordinal": 5,
+        "name": "display_name",
+        "type_info": {
+          "type": "VarString",
+          "flags": "NOT_NULL | BINARY | NO_DEFAULT_VALUE",
+          "char_set": 224,
+          "max_size": 80
+        }
+      }
+    ],
+    "parameters": {
+      "Right": 1
+    },
+    "nullable": [
+      false,
+      true,
+      false,
+      false,
+      false,
+      false
+    ]
+  },
+  "hash": "3390084f700ef2444691a02c691a59ccdd66bc8b096547e89c68b58b04dd44e4"
+}

.sqlx/query-35b09082ebb923c8c3191eaee8553b7c3badbd9152ee43999f7c8ff1a6410fe9.json

@@ -0,0 +1,102 @@
+{
+  "db_name": "MySQL",
+  "query": "\nSELECT\n    w.token as `token: tokens::tokens::wallets::WalletToken`,\n    w.wallet_namespace as `wallet_namespace: enums::common::payments_namespace::PaymentsNamespace`,\n    w.owner_user_token as `owner_user_token: tokens::tokens::users::UserToken`,\n    w.banked_credits as `banked_credits: u32`,\n    w.monthly_credits as `monthly_credits: u32`,\n    w.version,\n    w.created_at as `created_at: DateTime<Utc>`,\n    w.updated_at as `updated_at: DateTime<Utc>`\nFROM wallets as w\nWHERE w.token = ?\nLIMIT 1\n    ",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "token: tokens::tokens::wallets::WalletToken",
+        "type_info": {
+          "type": "VarString",
+          "flags": "NOT_NULL | UNIQUE_KEY | BINARY | NO_DEFAULT_VALUE",
+          "char_set": 224,
+          "max_size": 128
+        }
+      },
+      {
+        "ordinal": 1,
+        "name": "wallet_namespace: enums::common::payments_namespace::PaymentsNamespace",
+        "type_info": {
+          "type": "VarString",
+          "flags": "NOT_NULL | MULTIPLE_KEY | BINARY | NO_DEFAULT_VALUE",
+          "char_set": 224,
+          "max_size": 128
+        }
+      },
+      {
+        "ordinal": 2,
+        "name": "owner_user_token: tokens::tokens::users::UserToken",
+        "type_info": {
+          "type": "VarString",
+          "flags": "NOT_NULL | MULTIPLE_KEY | BINARY | NO_DEFAULT_VALUE",
+          "char_set": 224,
+          "max_size": 128
+        }
+      },
+      {
+        "ordinal": 3,
+        "name": "banked_credits: u32",
+        "type_info": {
+          "type": "Long",
+          "flags": "NOT_NULL | UNSIGNED",
+          "char_set": 63,
+          "max_size": 10
+        }
+      },
+      {
+        "ordinal": 4,
+        "name": "monthly_credits: u32",
+        "type_info": {
+          "type": "Long",
+          "flags": "NOT_NULL | UNSIGNED",
+          "char_set": 63,
+          "max_size": 10
+        }
+      },
+      {
+        "ordinal": 5,
+        "name": "version",
+        "type_info": {
+          "type": "Long",
+          "flags": "NOT_NULL",
+          "char_set": 63,
+          "max_size": 11
+        }
+      },
+      {
+        "ordinal": 6,
+        "name": "created_at: DateTime<Utc>",
+        "type_info": {
+          "type": "Timestamp",
+          "flags": "NOT_NULL | BINARY | TIMESTAMP",
+          "char_set": 63,
+          "max_size": 19
+        }
+      },
+      {
+        "ordinal": 7,
+        "name": "updated_at: DateTime<Utc>",
+        "type_info": {
+          "type": "Timestamp",
+          "flags": "NOT_NULL | BINARY | TIMESTAMP | ON_UPDATE_NOW",
+          "char_set": 63,
+          "max_size": 19
+        }
+      }
+    ],
+    "parameters": {
+      "Right": 1
+    },
+    "nullable": [
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+      false
+    ]
+  },
+  "hash": "35b09082ebb923c8c3191eaee8553b7c3badbd9152ee43999f7c8ff1a6410fe9"
+}

.sqlx/query-69b6e933ad400bc574204de301dde6748d2a1723f47c12e86afc05033a60d3a2.json

@@ -0,0 +1,91 @@
+{
+  "db_name": "MySQL",
+  "query": "\nSELECT\n    w.token as `token: tokens::tokens::wallets::WalletToken`,\n    w.wallet_namespace as `wallet_namespace: enums::common::payments_namespace::PaymentsNamespace`,\n    w.banked_credits as `banked_credits: u32`,\n    w.monthly_credits as `monthly_credits: u32`,\n    w.version,\n    w.created_at as `created_at: DateTime<Utc>`,\n    w.updated_at as `updated_at: DateTime<Utc>`\nFROM wallets as w\nWHERE w.owner_user_token = ?\nORDER BY w.id DESC\n    ",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "token: tokens::tokens::wallets::WalletToken",
+        "type_info": {
+          "type": "VarString",
+          "flags": "NOT_NULL | UNIQUE_KEY | BINARY | NO_DEFAULT_VALUE",
+          "char_set": 224,
+          "max_size": 128
+        }
+      },
+      {
+        "ordinal": 1,
+        "name": "wallet_namespace: enums::common::payments_namespace::PaymentsNamespace",
+        "type_info": {
+          "type": "VarString",
+          "flags": "NOT_NULL | MULTIPLE_KEY | BINARY | NO_DEFAULT_VALUE",
+          "char_set": 224,
+          "max_size": 128
+        }
+      },
+      {
+        "ordinal": 2,
+        "name": "banked_credits: u32",
+        "type_info": {
+          "type": "Long",
+          "flags": "NOT_NULL | UNSIGNED",
+          "char_set": 63,
+          "max_size": 10
+        }
+      },
+      {
+        "ordinal": 3,
+        "name": "monthly_credits: u32",
+        "type_info": {
+          "type": "Long",
+          "flags": "NOT_NULL | UNSIGNED",
+          "char_set": 63,
+          "max_size": 10
+        }
+      },
+      {
+        "ordinal": 4,
+        "name": "version",
+        "type_info": {
+          "type": "Long",
+          "flags": "NOT_NULL",
+          "char_set": 63,
+          "max_size": 11
+        }
+      },
+      {
+        "ordinal": 5,
+        "name": "created_at: DateTime<Utc>",
+        "type_info": {
+          "type": "Timestamp",
+          "flags": "NOT_NULL | BINARY | TIMESTAMP",
+          "char_set": 63,
+          "max_size": 19
+        }
+      },
+      {
+        "ordinal": 6,
+        "name": "updated_at: DateTime<Utc>",
+        "type_info": {
+          "type": "Timestamp",
+          "flags": "NOT_NULL | BINARY | TIMESTAMP | ON_UPDATE_NOW",
+          "char_set": 63,
+          "max_size": 19
+        }
+      }
+    ],
+    "parameters": {
+      "Right": 1
+    },
+    "nullable": [
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+      false
+    ]
+  },
+  "hash": "69b6e933ad400bc574204de301dde6748d2a1723f47c12e86afc05033a60d3a2"
+}

.sqlx/query-7f874f4ac43d8c66e3ea8cb2fb56f57b93047355dd9faee4df48799f6d1be00a.json

@@ -0,0 +1,146 @@
+{
+  "db_name": "MySQL",
+  "query": "\nSELECT\n    token as `token: tokens::tokens::wallet_ledger_entries::WalletLedgerEntryToken`,\n    wallet_token as `wallet_token: tokens::tokens::wallets::WalletToken`,\n    entry_type as `entry_type: enums::by_table::wallet_ledger_entries::wallet_ledger_entry_type::WalletLedgerEntryType`,\n    maybe_entity_ref,\n    credits_delta,\n    banked_credits_before as `banked_credits_before: u32`,\n    banked_credits_after as `banked_credits_after: u32`,\n    monthly_credits_before as `monthly_credits_before: u32`,\n    monthly_credits_after as `monthly_credits_after: u32`,\n    created_at as `created_at: DateTime<Utc>`,\n    is_refunded as `is_refunded: bool`,\n    maybe_linked_refund_ledger_token as `maybe_linked_refund_ledger_token: tokens::tokens::wallet_ledger_entries::WalletLedgerEntryToken`\nFROM wallet_ledger_entries\nWHERE wallet_token = ?\nORDER BY id DESC\n    ",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "token: tokens::tokens::wallet_ledger_entries::WalletLedgerEntryToken",
+        "type_info": {
+          "type": "VarString",
+          "flags": "NOT_NULL | UNIQUE_KEY | BINARY | NO_DEFAULT_VALUE",
+          "char_set": 224,
+          "max_size": 128
+        }
+      },
+      {
+        "ordinal": 1,
+        "name": "wallet_token: tokens::tokens::wallets::WalletToken",
+        "type_info": {
+          "type": "VarString",
+          "flags": "NOT_NULL | MULTIPLE_KEY | BINARY | NO_DEFAULT_VALUE",
+          "char_set": 224,
+          "max_size": 128
+        }
+      },
+      {
+        "ordinal": 2,
+        "name": "entry_type: enums::by_table::wallet_ledger_entries::wallet_ledger_entry_type::WalletLedgerEntryType",
+        "type_info": {
+          "type": "VarString",
+          "flags": "NOT_NULL | BINARY | NO_DEFAULT_VALUE",
+          "char_set": 224,
+          "max_size": 128
+        }
+      },
+      {
+        "ordinal": 3,
+        "name": "maybe_entity_ref",
+        "type_info": {
+          "type": "VarString",
+          "flags": "BINARY",
+          "char_set": 224,
+          "max_size": 1020
+        }
+      },
+      {
+        "ordinal": 4,
+        "name": "credits_delta",
+        "type_info": {
+          "type": "Long",
+          "flags": "NOT_NULL",
+          "char_set": 63,
+          "max_size": 11
+        }
+      },
+      {
+        "ordinal": 5,
+        "name": "banked_credits_before: u32",
+        "type_info": {
+          "type": "Long",
+          "flags": "NOT_NULL | UNSIGNED",
+          "char_set": 63,
+          "max_size": 10
+        }
+      },
+      {
+        "ordinal": 6,
+        "name": "banked_credits_after: u32",
+        "type_info": {
+          "type": "Long",
+          "flags": "NOT_NULL | UNSIGNED",
+          "char_set": 63,
+          "max_size": 10
+        }
+      },
+      {
+        "ordinal": 7,
+        "name": "monthly_credits_before: u32",
+        "type_info": {
+          "type": "Long",
+          "flags": "NOT_NULL | UNSIGNED",
+          "char_set": 63,
+          "max_size": 10
+        }
+      },
+      {
+        "ordinal": 8,
+        "name": "monthly_credits_after: u32",
+        "type_info": {
+          "type": "Long",
+          "flags": "NOT_NULL | UNSIGNED",
+          "char_set": 63,
+          "max_size": 10
+        }
+      },
+      {
+        "ordinal": 9,
+        "name": "created_at: DateTime<Utc>",
+        "type_info": {
+          "type": "Timestamp",
+          "flags": "NOT_NULL | BINARY | TIMESTAMP",
+          "char_set": 63,
+          "max_size": 19
+        }
+      },
+      {
+        "ordinal": 10,
+        "name": "is_refunded: bool",
+        "type_info": {
+          "type": "Tiny",
+          "flags": "NOT_NULL",
+          "char_set": 63,
+          "max_size": 1
+        }
+      },
+      {
+        "ordinal": 11,
+        "name": "maybe_linked_refund_ledger_token: tokens::tokens::wallet_ledger_entries::WalletLedgerEntryToken",
+        "type_info": {
+          "type": "VarString",
+          "flags": "BINARY",
+          "char_set": 224,
+          "max_size": 128
+        }
+      }
+    ],
+    "parameters": {
+      "Right": 1
+    },
+    "nullable": [
+      false,
+      false,
+      false,
+      true,
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+      true
+    ]
+  },
+  "hash": "7f874f4ac43d8c66e3ea8cb2fb56f57b93047355dd9faee4df48799f6d1be00a"
+}

.sqlx/query-80f73702374593c141d183d86bd8af73d37fd7118914d0ba12a02f53c1b84c78.json

@@ -0,0 +1,12 @@
+{
+  "db_name": "MySQL",
+  "query": "\n    INSERT INTO web_referrals (\n      url,\n      domain,\n      utm_source,\n      utm_medium,\n      utm_campaign,\n      ip_address,\n      anonymous_visitor_token\n    ) VALUES (?, ?, ?, ?, ?, ?, ?)\n    ",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 7
+    },
+    "nullable": []
+  },
+  "hash": "80f73702374593c141d183d86bd8af73d37fd7118914d0ba12a02f53c1b84c78"
+}

.sqlx/query-97599bdc5467b8750d2546cc6f78457c26d93c3be52921ad9b3531fd88498194.json

@@ -0,0 +1,201 @@
+{
+  "db_name": "MySQL",
+  "query": "\nSELECT\n    users.token as `user_token: tokens::tokens::users::UserToken`,\n    username,\n    display_name,\n    username_is_generated as `username_is_generated: bool`,\n    is_temporary as `is_temporary: bool`,\n    username_is_not_customized as `username_is_not_customized: bool`,\n    email_address,\n    email_confirmed as `email_confirmed: bool`,\n    email_is_synthetic as `email_is_synthetic: bool`,\n    is_without_password as `is_without_password: bool`,\n    ip_address_creation,\n    ip_address_last_login,\n    maybe_avatar_media_file_token as `maybe_avatar_media_file_token: tokens::tokens::media_files::MediaFileToken`,\n    email_gravatar_hash,\n    is_banned as `is_banned: bool`,\n    created_at,\n    updated_at\nFROM users\nWHERE\n    users.username = ?\n    AND users.user_deleted_at IS NULL\n    AND users.mod_deleted_at IS NULL\nLIMIT 1\n    ",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "user_token: tokens::tokens::users::UserToken",
+        "type_info": {
+          "type": "VarString",
+          "flags": "NOT_NULL | UNIQUE_KEY | BINARY | NO_DEFAULT_VALUE",
+          "char_set": 224,
+          "max_size": 128
+        }
+      },
+      {
+        "ordinal": 1,
+        "name": "username",
+        "type_info": {
+          "type": "VarString",
+          "flags": "NOT_NULL | UNIQUE_KEY | BINARY | NO_DEFAULT_VALUE",
+          "char_set": 224,
+          "max_size": 80
+        }
+      },
+      {
+        "ordinal": 2,
+        "name": "display_name",
+        "type_info": {
+          "type": "VarString",
+          "flags": "NOT_NULL | BINARY | NO_DEFAULT_VALUE",
+          "char_set": 224,
+          "max_size": 80
+        }
+      },
+      {
+        "ordinal": 3,
+        "name": "username_is_generated: bool",
+        "type_info": {
+          "type": "Tiny",
+          "flags": "NOT_NULL",
+          "char_set": 63,
+          "max_size": 1
+        }
+      },
+      {
+        "ordinal": 4,
+        "name": "is_temporary: bool",
+        "type_info": {
+          "type": "Tiny",
+          "flags": "NOT_NULL",
+          "char_set": 63,
+          "max_size": 1
+        }
+      },
+      {
+        "ordinal": 5,
+        "name": "username_is_not_customized: bool",
+        "type_info": {
+          "type": "Tiny",
+          "flags": "NOT_NULL",
+          "char_set": 63,
+          "max_size": 1
+        }
+      },
+      {
+        "ordinal": 6,
+        "name": "email_address",
+        "type_info": {
+          "type": "VarString",
+          "flags": "NOT_NULL | UNIQUE_KEY | BINARY | NO_DEFAULT_VALUE",
+          "char_set": 224,
+          "max_size": 1020
+        }
+      },
+      {
+        "ordinal": 7,
+        "name": "email_confirmed: bool",
+        "type_info": {
+          "type": "Tiny",
+          "flags": "NOT_NULL",
+          "char_set": 63,
+          "max_size": 1
+        }
+      },
+      {
+        "ordinal": 8,
+        "name": "email_is_synthetic: bool",
+        "type_info": {
+          "type": "Tiny",
+          "flags": "NOT_NULL",
+          "char_set": 63,
+          "max_size": 1
+        }
+      },
+      {
+        "ordinal": 9,
+        "name": "is_without_password: bool",
+        "type_info": {
+          "type": "Tiny",
+          "flags": "NOT_NULL",
+          "char_set": 63,
+          "max_size": 1
+        }
+      },
+      {
+        "ordinal": 10,
+        "name": "ip_address_creation",
+        "type_info": {
+          "type": "VarString",
+          "flags": "NOT_NULL | BINARY | NO_DEFAULT_VALUE",
+          "char_set": 224,
+          "max_size": 160
+        }
+      },
+      {
+        "ordinal": 11,
+        "name": "ip_address_last_login",
+        "type_info": {
+          "type": "VarString",
+          "flags": "NOT_NULL | BINARY | NO_DEFAULT_VALUE",
+          "char_set": 224,
+          "max_size": 160
+        }
+      },
+      {
+        "ordinal": 12,
+        "name": "maybe_avatar_media_file_token: tokens::tokens::media_files::MediaFileToken",
+        "type_info": {
+          "type": "VarString",
+          "flags": "MULTIPLE_KEY | BINARY",
+          "char_set": 224,
+          "max_size": 128
+        }
+      },
+      {
+        "ordinal": 13,
+        "name": "email_gravatar_hash",
+        "type_info": {
+          "type": "String",
+          "flags": "NOT_NULL | BINARY | NO_DEFAULT_VALUE",
+          "char_set": 224,
+          "max_size": 128
+        }
+      },
+      {
+        "ordinal": 14,
+        "name": "is_banned: bool",
+        "type_info": {
+          "type": "Tiny",
+          "flags": "NOT_NULL",
+          "char_set": 63,
+          "max_size": 1
+        }
+      },
+      {
+        "ordinal": 15,
+        "name": "created_at",
+        "type_info": {
+          "type": "Timestamp",
+          "flags": "NOT_NULL | BINARY | TIMESTAMP",
+          "char_set": 63,
+          "max_size": 19
+        }
+      },
+      {
+        "ordinal": 16,
+        "name": "updated_at",
+        "type_info": {
+          "type": "Timestamp",
+          "flags": "NOT_NULL | BINARY | TIMESTAMP | ON_UPDATE_NOW",
+          "char_set": 63,
+          "max_size": 19
+        }
+      }
+    ],
+    "parameters": {
+      "Right": 1
+    },
+    "nullable": [
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+      true,
+      false,
+      false,
+      false,
+      false
+    ]
+  },
+  "hash": "97599bdc5467b8750d2546cc6f78457c26d93c3be52921ad9b3531fd88498194"
+}

.sqlx/query-9c28e9f8f163407755acaca1fb4a72849679b6bf98b8c87e1761200300111232.json

@@ -0,0 +1,135 @@
+{
+  "db_name": "MySQL",
+  "query": "\nSELECT\n    token as `token: tokens::tokens::wallet_ledger_entries::WalletLedgerEntryToken`,\n    entry_type as `entry_type: enums::by_table::wallet_ledger_entries::wallet_ledger_entry_type::WalletLedgerEntryType`,\n    maybe_entity_ref,\n    credits_delta,\n    banked_credits_before as `banked_credits_before: u32`,\n    banked_credits_after as `banked_credits_after: u32`,\n    monthly_credits_before as `monthly_credits_before: u32`,\n    monthly_credits_after as `monthly_credits_after: u32`,\n    is_refunded as `is_refunded: bool`,\n    maybe_linked_refund_ledger_token as `maybe_linked_refund_ledger_token: tokens::tokens::wallet_ledger_entries::WalletLedgerEntryToken`,\n    created_at as `created_at: DateTime<Utc>`\nFROM wallet_ledger_entries\nWHERE token = ?\nLIMIT 1\n    ",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "token: tokens::tokens::wallet_ledger_entries::WalletLedgerEntryToken",
+        "type_info": {
+          "type": "VarString",
+          "flags": "NOT_NULL | UNIQUE_KEY | BINARY | NO_DEFAULT_VALUE",
+          "char_set": 224,
+          "max_size": 128
+        }
+      },
+      {
+        "ordinal": 1,
+        "name": "entry_type: enums::by_table::wallet_ledger_entries::wallet_ledger_entry_type::WalletLedgerEntryType",
+        "type_info": {
+          "type": "VarString",
+          "flags": "NOT_NULL | BINARY | NO_DEFAULT_VALUE",
+          "char_set": 224,
+          "max_size": 128
+        }
+      },
+      {
+        "ordinal": 2,
+        "name": "maybe_entity_ref",
+        "type_info": {
+          "type": "VarString",
+          "flags": "BINARY",
+          "char_set": 224,
+          "max_size": 1020
+        }
+      },
+      {
+        "ordinal": 3,
+        "name": "credits_delta",
+        "type_info": {
+          "type": "Long",
+          "flags": "NOT_NULL",
+          "char_set": 63,
+          "max_size": 11
+        }
+      },
+      {
+        "ordinal": 4,
+        "name": "banked_credits_before: u32",
+        "type_info": {
+          "type": "Long",
+          "flags": "NOT_NULL | UNSIGNED",
+          "char_set": 63,
+          "max_size": 10
+        }
+      },
+      {
+        "ordinal": 5,
+        "name": "banked_credits_after: u32",
+        "type_info": {
+          "type": "Long",
+          "flags": "NOT_NULL | UNSIGNED",
+          "char_set": 63,
+          "max_size": 10
+        }
+      },
+      {
+        "ordinal": 6,
+        "name": "monthly_credits_before: u32",
+        "type_info": {
+          "type": "Long",
+          "flags": "NOT_NULL | UNSIGNED",
+          "char_set": 63,
+          "max_size": 10
+        }
+      },
+      {
+        "ordinal": 7,
+        "name": "monthly_credits_after: u32",
+        "type_info": {
+          "type": "Long",
+          "flags": "NOT_NULL | UNSIGNED",
+          "char_set": 63,
+          "max_size": 10
+        }
+      },
+      {
+        "ordinal": 8,
+        "name": "is_refunded: bool",
+        "type_info": {
+          "type": "Tiny",
+          "flags": "NOT_NULL",
+          "char_set": 63,
+          "max_size": 1
+        }
+      },
+      {
+        "ordinal": 9,
+        "name": "maybe_linked_refund_ledger_token: tokens::tokens::wallet_ledger_entries::WalletLedgerEntryToken",
+        "type_info": {
+          "type": "VarString",
+          "flags": "BINARY",
+          "char_set": 224,
+          "max_size": 128
+        }
+      },
+      {
+        "ordinal": 10,
+        "name": "created_at: DateTime<Utc>",
+        "type_info": {
+          "type": "Timestamp",
+          "flags": "NOT_NULL | BINARY | TIMESTAMP",
+          "char_set": 63,
+          "max_size": 19
+        }
+      }
+    ],
+    "parameters": {
+      "Right": 1
+    },
+    "nullable": [
+      false,
+      false,
+      true,
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+      true,
+      false
+    ]
+  },
+  "hash": "9c28e9f8f163407755acaca1fb4a72849679b6bf98b8c87e1761200300111232"
+}

.sqlx/query-d023eb33c9a06f8b07b1e5d1e255dbb730244bbd764a49d519473e50751a3ddc.json

@@ -0,0 +1,201 @@
+{
+  "db_name": "MySQL",
+  "query": "\nSELECT\n    users.token as `user_token: tokens::tokens::users::UserToken`,\n    username,\n    display_name,\n    username_is_generated as `username_is_generated: bool`,\n    is_temporary as `is_temporary: bool`,\n    username_is_not_customized as `username_is_not_customized: bool`,\n    email_address,\n    email_confirmed as `email_confirmed: bool`,\n    email_is_synthetic as `email_is_synthetic: bool`,\n    is_without_password as `is_without_password: bool`,\n    ip_address_creation,\n    ip_address_last_login,\n    maybe_avatar_media_file_token as `maybe_avatar_media_file_token: tokens::tokens::media_files::MediaFileToken`,\n    email_gravatar_hash,\n    is_banned as `is_banned: bool`,\n    created_at,\n    updated_at\nFROM users\nWHERE\n    users.email_address = ?\n    AND users.user_deleted_at IS NULL\n    AND users.mod_deleted_at IS NULL\nLIMIT 1\n    ",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "user_token: tokens::tokens::users::UserToken",
+        "type_info": {
+          "type": "VarString",
+          "flags": "NOT_NULL | UNIQUE_KEY | BINARY | NO_DEFAULT_VALUE",
+          "char_set": 224,
+          "max_size": 128
+        }
+      },
+      {
+        "ordinal": 1,
+        "name": "username",
+        "type_info": {
+          "type": "VarString",
+          "flags": "NOT_NULL | UNIQUE_KEY | BINARY | NO_DEFAULT_VALUE",
+          "char_set": 224,
+          "max_size": 80
+        }
+      },
+      {
+        "ordinal": 2,
+        "name": "display_name",
+        "type_info": {
+          "type": "VarString",
+          "flags": "NOT_NULL | BINARY | NO_DEFAULT_VALUE",
+          "char_set": 224,
+          "max_size": 80
+        }
+      },
+      {
+        "ordinal": 3,
+        "name": "username_is_generated: bool",
+        "type_info": {
+          "type": "Tiny",
+          "flags": "NOT_NULL",
+          "char_set": 63,
+          "max_size": 1
+        }
+      },
+      {
+        "ordinal": 4,
+        "name": "is_temporary: bool",
+        "type_info": {
+          "type": "Tiny",
+          "flags": "NOT_NULL",
+          "char_set": 63,
+          "max_size": 1
+        }
+      },
+      {
+        "ordinal": 5,
+        "name": "username_is_not_customized: bool",
+        "type_info": {
+          "type": "Tiny",
+          "flags": "NOT_NULL",
+          "char_set": 63,
+          "max_size": 1
+        }
+      },
+      {
+        "ordinal": 6,
+        "name": "email_address",
+        "type_info": {
+          "type": "VarString",
+          "flags": "NOT_NULL | UNIQUE_KEY | BINARY | NO_DEFAULT_VALUE",
+          "char_set": 224,
+          "max_size": 1020
+        }
+      },
+      {
+        "ordinal": 7,
+        "name": "email_confirmed: bool",
+        "type_info": {
+          "type": "Tiny",
+          "flags": "NOT_NULL",
+          "char_set": 63,
+          "max_size": 1
+        }
+      },
+      {
+        "ordinal": 8,
+        "name": "email_is_synthetic: bool",
+        "type_info": {
+          "type": "Tiny",
+          "flags": "NOT_NULL",
+          "char_set": 63,
+          "max_size": 1
+        }
+      },
+      {
+        "ordinal": 9,
+        "name": "is_without_password: bool",
+        "type_info": {
+          "type": "Tiny",
+          "flags": "NOT_NULL",
+          "char_set": 63,
+          "max_size": 1
+        }
+      },
+      {
+        "ordinal": 10,
+        "name": "ip_address_creation",
+        "type_info": {
+          "type": "VarString",
+          "flags": "NOT_NULL | BINARY | NO_DEFAULT_VALUE",
+          "char_set": 224,
+          "max_size": 160
+        }
+      },
+      {
+        "ordinal": 11,
+        "name": "ip_address_last_login",
+        "type_info": {
+          "type": "VarString",
+          "flags": "NOT_NULL | BINARY | NO_DEFAULT_VALUE",
+          "char_set": 224,
+          "max_size": 160
+        }
+      },
+      {
+        "ordinal": 12,
+        "name": "maybe_avatar_media_file_token: tokens::tokens::media_files::MediaFileToken",
+        "type_info": {
+          "type": "VarString",
+          "flags": "MULTIPLE_KEY | BINARY",
+          "char_set": 224,
+          "max_size": 128
+        }
+      },
+      {
+        "ordinal": 13,
+        "name": "email_gravatar_hash",
+        "type_info": {
+          "type": "String",
+          "flags": "NOT_NULL | BINARY | NO_DEFAULT_VALUE",
+          "char_set": 224,
+          "max_size": 128
+        }
+      },
+      {
+        "ordinal": 14,
+        "name": "is_banned: bool",
+        "type_info": {
+          "type": "Tiny",
+          "flags": "NOT_NULL",
+          "char_set": 63,
+          "max_size": 1
+        }
+      },
+      {
+        "ordinal": 15,
+        "name": "created_at",
+        "type_info": {
+          "type": "Timestamp",
+          "flags": "NOT_NULL | BINARY | TIMESTAMP",
+          "char_set": 63,
+          "max_size": 19
+        }
+      },
+      {
+        "ordinal": 16,
+        "name": "updated_at",
+        "type_info": {
+          "type": "Timestamp",
+          "flags": "NOT_NULL | BINARY | TIMESTAMP | ON_UPDATE_NOW",
+          "char_set": 63,
+          "max_size": 19
+        }
+      }
+    ],
+    "parameters": {
+      "Right": 1
+    },
+    "nullable": [
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+      true,
+      false,
+      false,
+      false,
+      false
+    ]
+  },
+  "hash": "d023eb33c9a06f8b07b1e5d1e255dbb730244bbd764a49d519473e50751a3ddc"
+}

.sqlx/query-fd92483d9f1849d5b7f04076446fa98688fec46bb1cba20d005bc8dad4d1c093.json

@@ -0,0 +1,201 @@
+{
+  "db_name": "MySQL",
+  "query": "\nSELECT\n    users.token as `user_token: tokens::tokens::users::UserToken`,\n    username,\n    display_name,\n    username_is_generated as `username_is_generated: bool`,\n    is_temporary as `is_temporary: bool`,\n    username_is_not_customized as `username_is_not_customized: bool`,\n    email_address,\n    email_confirmed as `email_confirmed: bool`,\n    email_is_synthetic as `email_is_synthetic: bool`,\n    is_without_password as `is_without_password: bool`,\n    ip_address_creation,\n    ip_address_last_login,\n    maybe_avatar_media_file_token as `maybe_avatar_media_file_token: tokens::tokens::media_files::MediaFileToken`,\n    email_gravatar_hash,\n    is_banned as `is_banned: bool`,\n    created_at,\n    updated_at\nFROM users\nWHERE\n    users.token = ?\n    AND users.user_deleted_at IS NULL\n    AND users.mod_deleted_at IS NULL\nLIMIT 1\n    ",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "user_token: tokens::tokens::users::UserToken",
+        "type_info": {
+          "type": "VarString",
+          "flags": "NOT_NULL | UNIQUE_KEY | BINARY | NO_DEFAULT_VALUE",
+          "char_set": 224,
+          "max_size": 128
+        }
+      },
+      {
+        "ordinal": 1,
+        "name": "username",
+        "type_info": {
+          "type": "VarString",
+          "flags": "NOT_NULL | UNIQUE_KEY | BINARY | NO_DEFAULT_VALUE",
+          "char_set": 224,
+          "max_size": 80
+        }
+      },
+      {
+        "ordinal": 2,
+        "name": "display_name",
+        "type_info": {
+          "type": "VarString",
+          "flags": "NOT_NULL | BINARY | NO_DEFAULT_VALUE",
+          "char_set": 224,
+          "max_size": 80
+        }
+      },
+      {
+        "ordinal": 3,
+        "name": "username_is_generated: bool",
+        "type_info": {
+          "type": "Tiny",
+          "flags": "NOT_NULL",
+          "char_set": 63,
+          "max_size": 1
+        }
+      },
+      {
+        "ordinal": 4,
+        "name": "is_temporary: bool",
+        "type_info": {
+          "type": "Tiny",
+          "flags": "NOT_NULL",
+          "char_set": 63,
+          "max_size": 1
+        }
+      },
+      {
+        "ordinal": 5,
+        "name": "username_is_not_customized: bool",
+        "type_info": {
+          "type": "Tiny",
+          "flags": "NOT_NULL",
+          "char_set": 63,
+          "max_size": 1
+        }
+      },
+      {
+        "ordinal": 6,
+        "name": "email_address",
+        "type_info": {
+          "type": "VarString",
+          "flags": "NOT_NULL | UNIQUE_KEY | BINARY | NO_DEFAULT_VALUE",
+          "char_set": 224,
+          "max_size": 1020
+        }
+      },
+      {
+        "ordinal": 7,
+        "name": "email_confirmed: bool",
+        "type_info": {
+          "type": "Tiny",
+          "flags": "NOT_NULL",
+          "char_set": 63,
+          "max_size": 1
+        }
+      },
+      {
+        "ordinal": 8,
+        "name": "email_is_synthetic: bool",
+        "type_info": {
+          "type": "Tiny",
+          "flags": "NOT_NULL",
+          "char_set": 63,
+          "max_size": 1
+        }
+      },
+      {
+        "ordinal": 9,
+        "name": "is_without_password: bool",
+        "type_info": {
+          "type": "Tiny",
+          "flags": "NOT_NULL",
+          "char_set": 63,
+          "max_size": 1
+        }
+      },
+      {
+        "ordinal": 10,
+        "name": "ip_address_creation",
+        "type_info": {
+          "type": "VarString",
+          "flags": "NOT_NULL | BINARY | NO_DEFAULT_VALUE",
+          "char_set": 224,
+          "max_size": 160
+        }
+      },
+      {
+        "ordinal": 11,
+        "name": "ip_address_last_login",
+        "type_info": {
+          "type": "VarString",
+          "flags": "NOT_NULL | BINARY | NO_DEFAULT_VALUE",
+          "char_set": 224,
+          "max_size": 160
+        }
+      },
+      {
+        "ordinal": 12,
+        "name": "maybe_avatar_media_file_token: tokens::tokens::media_files::MediaFileToken",
+        "type_info": {
+          "type": "VarString",
+          "flags": "MULTIPLE_KEY | BINARY",
+          "char_set": 224,
+          "max_size": 128
+        }
+      },
+      {
+        "ordinal": 13,
+        "name": "email_gravatar_hash",
+        "type_info": {
+          "type": "String",
+          "flags": "NOT_NULL | BINARY | NO_DEFAULT_VALUE",
+          "char_set": 224,
+          "max_size": 128
+        }
+      },
+      {
+        "ordinal": 14,
+        "name": "is_banned: bool",
+        "type_info": {
+          "type": "Tiny",
+          "flags": "NOT_NULL",
+          "char_set": 63,
+          "max_size": 1
+        }
+      },
+      {
+        "ordinal": 15,
+        "name": "created_at",
+        "type_info": {
+          "type": "Timestamp",
+          "flags": "NOT_NULL | BINARY | TIMESTAMP",
+          "char_set": 63,
+          "max_size": 19
+        }
+      },
+      {
+        "ordinal": 16,
+        "name": "updated_at",
+        "type_info": {
+          "type": "Timestamp",
+          "flags": "NOT_NULL | BINARY | TIMESTAMP | ON_UPDATE_NOW",
+          "char_set": 63,
+          "max_size": 19
+        }
+      }
+    ],
+    "parameters": {
+      "Right": 1
+    },
+    "nullable": [
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+      true,
+      false,
+      false,
+      false,
+      false
+    ]
+  },
+  "hash": "fd92483d9f1849d5b7f04076446fa98688fec46bb1cba20d005bc8dad4d1c093"
+}

Cargo.lock

@@ -791,6 +791,7 @@ dependencies = [
  "seedance2pro",
  "serde",
  "serde_derive",
+ "strum 0.28.0",
  "test_data",
  "tokens",
  "tokio",
@@ -1523,7 +1524,7 @@ dependencies = [
  "bitflags 2.11.0",
  "cexpr",
  "clang-sys",
- "itertools 0.11.0",
+ "itertools 0.13.0",
  "proc-macro2",
  "quote",
  "regex",
@@ -3471,7 +3472,7 @@ version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "330c60081dcc4c72131f8eb70510f1ac07223e5d4163db481a04a0befcffa412"
 dependencies = [
- "libloading 0.7.4",
+ "libloading 0.8.6",
 ]
 
 [[package]]
@@ -3776,7 +3777,7 @@ dependencies = [
  "serde_json",
  "sqlx",
  "storyteller_root",
- "strum",
+ "strum 0.26.2",
  "tokens",
  "tokio",
  "workspace-build-acceleration",
@@ -3938,7 +3939,7 @@ dependencies = [
  "sqlx",
  "sqlx-core",
  "sqlx-mysql",
- "strum",
+ "strum 0.26.2",
  "toml 0.8.23",
  "utoipa",
  "workspace-build-acceleration",
@@ -3952,7 +3953,7 @@ dependencies = [
  "serde",
  "serde_derive",
  "serde_json",
- "strum",
+ "strum 0.26.2",
  "toml 0.8.23",
  "utoipa",
  "workspace-build-acceleration",
@@ -4184,6 +4185,7 @@ dependencies = [
  "log",
  "reqwest 0.12.23",
  "serde",
+ "strum 0.28.0",
  "test_data",
  "testing",
  "tokio",
@@ -6501,7 +6503,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fc2f4eb4bc735547cfed7c0a4922cbd04a4655978c09b54f1f7b228750664c34"
 dependencies = [
  "cfg-if",
- "windows-targets 0.48.5",
+ "windows-targets 0.52.6",
 ]
 
 [[package]]
@@ -7066,7 +7068,7 @@ dependencies = [
  "serde_json",
  "sqlx",
  "storyteller_root",
- "strum",
+ "strum 0.26.2",
  "tempdir",
  "tokens",
  "tokio",
@@ -11581,8 +11583,8 @@ dependencies = [
  "server_environment",
  "speculoos",
  "sqlx",
- "strum",
- "strum_macros",
+ "strum 0.26.2",
+ "strum_macros 0.26.4",
  "tempdir",
  "tempfile",
  "testing",
@@ -11667,7 +11669,16 @@ version = "0.26.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5d8cec3501a5194c432b2b7976db6b7d10ec95c253208b45f83f7136aa985e29"
 dependencies = [
- "strum_macros",
+ "strum_macros 0.26.4",
+]
+
+[[package]]
+name = "strum"
+version = "0.28.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9628de9b8791db39ceda2b119bbe13134770b56c138ec1d3af810d045c04f9bd"
+dependencies = [
+ "strum_macros 0.28.0",
 ]
 
 [[package]]
@@ -11683,6 +11694,18 @@ dependencies = [
  "syn 2.0.106",
 ]
 
+[[package]]
+name = "strum_macros"
+version = "0.28.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab85eea0270ee17587ed4156089e10b9e6880ee688791d45a905f5b1ca36f664"
+dependencies = [
+ "heck 0.5.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.106",
+]
+
 [[package]]
 name = "subprocess"
 version = "0.2.9"
@@ -12679,7 +12702,7 @@ dependencies = [
  "sqlx",
  "sqlx-core",
  "sqlx-mysql",
- "strum",
+ "strum 0.26.2",
  "utoipa",
  "workspace-build-acceleration",
 ]
@@ -14029,7 +14052,7 @@ dependencies = [
  "serde",
  "serde_derive",
  "serde_json",
- "strum",
+ "strum 0.26.2",
  "workspace-build-acceleration",
 ]
 
@@ -14984,6 +15007,25 @@ dependencies = [
  "zstd-sys",
 ]
 
+[[package]]
+name = "world_labs_api"
+version = "0.0.1"
+dependencies = [
+ "anyhow",
+ "chrono",
+ "env",
+ "env_logger 0.11.9",
+ "errors",
+ "filesys",
+ "log",
+ "serde",
+ "serde_json",
+ "tokio",
+ "uuid 1.18.1",
+ "workspace-build-acceleration",
+ "wreq",
+]
+
 [[package]]
 name = "world_labs_client"
 version = "0.0.1"

Cargo.toml

@@ -19,6 +19,7 @@ members = [
   "crates/api_clients/seedance2pro",
   "crates/api_clients/runwayml_client",
   "crates/api_clients/thumbnail_generator",
+  "crates/api_clients/world_labs_api",
   "crates/api_clients/world_labs_client",
 
   # CLI tools for operations, etc.
@@ -248,6 +249,7 @@ tokens = { path = "crates/schema/public/tokens" }
 url_utils = { path = "crates/lib/url_utils" }
 users = { path = "crates/lib/users" }
 web_base64 = { path = "crates/lib/data/web_base64" }
+world_labs_api = { path = "crates/api_clients/world_labs_api" }
 world_labs_client = { path = "crates/api_clients/world_labs_client" }
 
 # External libs
@@ -283,12 +285,13 @@ redis = { version = "1.0.2", features = ["r2d2", "tokio-rustls-comp", "tokio-com
 regex = "1.12.3"
 reqwest = { version = "0.12.23", default-features = false, features = [ "charset", "http2", "system-proxy", "json", "cookies", "rustls-tls", "gzip" ] }
 reqwest-websocket = {  version = "0.5.0" }
-serde = {  version = "1.0.219", features = ["derive"] }
+serde = { version = "1.0.219", features = ["derive"] }
 serde_derive = "1.0.219"
 serde_json = "1.0.140"
 serde_yaml = "0.9.34+deprecated"
 sha2 = "0.11.0-rc.2"
 sha3 = "0.10.8"
+strum = { version = "0.28.0", features = ["derive"] }
 tauri = { version = "2.8.3", features = ["unstable", "devtools"] } # NB: "devtools" prevents App Store distribution; "ubstable" is needed for window access
 tauri-plugin-dialog = "2.3.3"
 tauri-plugin-fs = "2.4.2"

README.md

@@ -55,7 +55,7 @@ We haven't abandoned text-to-asset generation for quick prototyping and ideation
 
 | Provider   | Features                                                                                                                                                                |
 |------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| Artcraft   | Nano Banana, Nano Banana Pro, GPT-Image-1 / 1.5, Seedance 2 / Seedream 4 / 4.5, Flux 1.1 / Kontext, Veo 2 / 3 / 3.1, Kling 1.6 / 2.1 / 2.5 / 2.6, Seedance, Sora 2 / Pro, Hunyuan 3d 2 / 3 |
+| Artcraft   | Nano Banana, Nano Banana Pro, GPT-Image-1 / 1.5, Seedance 1.0 Lite / 1.5 Pro / 2.0, Seedream 4 / 4.5, Flux 1.1 / Kontext, Veo 2 / 3 / 3.1, Kling 1.6 / 2.1 / 2.5 / 2.6, Sora 2 / Pro, Hunyuan 3d 2 / 3 |
 | Grok       | Grok Imagine, Grok Video                                                                                                                                                |
 | Midjourney | Image Gen (all versions)                                                                                                                                                |
 | Sora       | Sora 1, Sora 2, GPT-Image-1                                                                                                                                             |

_database/sql/migrations/2026-03-05-233724-0000_alter_users_add_referral_url/down.sql

@@ -0,0 +1,7 @@
+-- noinspection SqlDialectInspectionForFile
+-- noinspection SqlNoDataSourceInspectionForFile
+-- noinspection SqlResolveForFile
+
+ALTER TABLE users
+DROP COLUMN
+maybe_referral_url;

_database/sql/migrations/2026-03-05-233724-0000_alter_users_add_referral_url/up.sql

@@ -0,0 +1,7 @@
+-- noinspection SqlDialectInspectionForFile
+-- noinspection SqlNoDataSourceInspectionForFile
+-- noinspection SqlResolveForFile
+
+ALTER TABLE users
+ADD COLUMN
+maybe_referral_url VARCHAR(255) DEFAULT NULL;

_database/sql/migrations/2026-03-05-233845-0000_web_referrals/down.sql

@@ -0,0 +1,5 @@
+-- noinspection SqlDialectInspectionForFile
+-- noinspection SqlNoDataSourceInspectionForFile
+-- noinspection SqlResolveForFile
+
+DROP TABLE web_referrals;

_database/sql/migrations/2026-03-05-233845-0000_web_referrals/up.sql

@@ -0,0 +1,27 @@
+-- noinspection SqlDialectInspectionForFile
+-- noinspection SqlNoDataSourceInspectionForFile
+-- noinspection SqlResolveForFile
+
+-- Records of web referrals
+CREATE TABLE web_referrals (
+  -- Not used for anything except replication.
+  id BIGINT(20) NOT NULL AUTO_INCREMENT,
+
+  -- The referral URL
+  url VARCHAR(255) NOT NULL,
+
+  -- The parsed out referral domain
+  domain VARCHAR(255) DEFAULT NULL,
+
+  utm_source VARCHAR(32) DEFAULT NULL,
+
+  utm_medium  VARCHAR(32) DEFAULT NULL,
+
+  utm_campaign VARCHAR(255) DEFAULT NULL,
+
+  created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+  -- ========== INDICES ==========
+  PRIMARY KEY (id)
+
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin;

_database/sql/migrations/2026-03-06-011058-0000_alter_web_referrals_add_ip_and_avt/down.sql

@@ -0,0 +1,7 @@
+-- noinspection SqlDialectInspectionForFile
+-- noinspection SqlNoDataSourceInspectionForFile
+-- noinspection SqlResolveForFile
+
+ALTER TABLE web_referrals
+DROP COLUMN ip_address,
+DROP COLUMN anonymous_visitor_token;

_database/sql/migrations/2026-03-06-011058-0000_alter_web_referrals_add_ip_and_avt/up.sql

@@ -0,0 +1,7 @@
+-- noinspection SqlDialectInspectionForFile
+-- noinspection SqlNoDataSourceInspectionForFile
+-- noinspection SqlResolveForFile
+
+ALTER TABLE web_referrals
+ADD COLUMN ip_address VARCHAR(40) NOT NULL,
+ADD COLUMN anonymous_visitor_token VARCHAR(32) DEFAULT NULL;

_database/sql/migrations/2026-03-06-022242-0000_alter_web_referrals_widen_fields/down.sql

@@ -0,0 +1,8 @@
+-- noinspection SqlDialectInspectionForFile
+-- noinspection SqlNoDataSourceInspectionForFile
+-- noinspection SqlResolveForFile
+
+ALTER TABLE web_referrals
+MODIFY COLUMN utm_source VARCHAR(32) DEFAULT NULL,
+MODIFY COLUMN utm_medium VARCHAR(32) DEFAULT NULL,
+MODIFY COLUMN utm_campaign VARCHAR(255) DEFAULT NULL;

_database/sql/migrations/2026-03-06-022242-0000_alter_web_referrals_widen_fields/up.sql

@@ -0,0 +1,8 @@
+-- noinspection SqlDialectInspectionForFile
+-- noinspection SqlNoDataSourceInspectionForFile
+-- noinspection SqlResolveForFile
+
+ALTER TABLE web_referrals
+MODIFY COLUMN utm_source VARCHAR(150) DEFAULT NULL,
+MODIFY COLUMN utm_medium VARCHAR(150) DEFAULT NULL,
+MODIFY COLUMN utm_campaign VARCHAR(150) DEFAULT NULL;

_database/sql/migrations_squashed/user_tables/users.sql

@@ -220,6 +220,9 @@ CREATE TABLE users (
   -- statistical evaluation.)
   was_eagerly_provisioned BOOLEAN NOT NULL DEFAULT false,
 
+  -- The referral URL the user arrived from when signing up.
+  maybe_referral_url VARCHAR(255) DEFAULT NULL,
+
   -- ========== MODERATION DETAILS ==========
 
   -- Different than deleted.

_database/sql/migrations_squashed/web_referrals.sql

@@ -0,0 +1,31 @@
+-- noinspection SqlDialectInspectionForFile
+-- noinspection SqlNoDataSourceInspectionForFile
+-- noinspection SqlResolveForFile
+
+-- Records of web referrals
+CREATE TABLE web_referrals (
+  -- Not used for anything except replication.
+  id BIGINT(20) NOT NULL AUTO_INCREMENT,
+
+  -- The referral URL
+  url VARCHAR(255) NOT NULL,
+
+  -- The parsed out referral domain
+  domain VARCHAR(255) DEFAULT NULL,
+
+  utm_source VARCHAR(150) DEFAULT NULL,
+
+  utm_medium  VARCHAR(150) DEFAULT NULL,
+
+  utm_campaign VARCHAR(150) DEFAULT NULL,
+
+  ip_address VARCHAR(40) NOT NULL,
+
+  anonymous_visitor_token VARCHAR(32) DEFAULT NULL,
+
+  created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+  -- ========== INDICES ==========
+  PRIMARY KEY (id)
+
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin;

crates/api_clients/artcraft/artcraft_api_defs/src/generate/cost_estimate/estimate_video_cost.rs

@@ -9,7 +9,10 @@ use enums::common::generation_provider::GenerationProvider;
 pub const ESTIMATE_VIDEO_COST_PATH: &str = "/v1/generate/cost_estimate/video";
 
 /// Request body for the video cost estimate endpoint.
-#[derive(Serialize, Deserialize, ToSchema)]
+///
+/// Every model cares about its own set of parameters and not all
+/// parameters may be relevant for every model.
+#[derive(Serialize, Deserialize, ToSchema, Debug)]
 pub struct EstimateVideoCostRequest {
   /// The video model to estimate costs for.
   pub model: CommonVideoModel,
@@ -34,10 +37,13 @@ pub struct EstimateVideoCostRequest {
 
   /// Number of videos to generate in parallel.
   pub video_batch_count: Option<u16>,
+
+  /// Whether to generate audio for the video.
+  pub generate_audio: Option<bool>,
 }
 
 /// Describes the type of video generation being requested.
-#[derive(Serialize, Deserialize, ToSchema)]
+#[derive(Serialize, Deserialize, ToSchema, Debug)]
 #[serde(tag = "type", rename_all = "snake_case")]
 pub enum GenerationMode {
   TextToVideo,
@@ -99,6 +105,7 @@ mod tests {
       resolution: None,
       duration_seconds: None,
       video_batch_count: None,
+      generate_audio: None,
     };
     let serialized = serde_json::to_string(&request).unwrap();
     assert!(serialized.contains("\"generation_mode\":{\"type\":\"text_to_video\"}"));
@@ -115,6 +122,7 @@ mod tests {
       resolution: None,
       duration_seconds: None,
       video_batch_count: None,
+      generate_audio: None,
     };
     let serialized = serde_json::to_string(&request).unwrap();
     assert!(serialized.contains("\"generation_mode\":{\"type\":\"reference_image_to_video\",\"count\":1}"));

crates/api_clients/artcraft/artcraft_api_defs/src/generate/image/multi_function/bytedance_seedream_5_lite_multi_function_image_gen.rs

@@ -0,0 +1,68 @@
+use serde_derive::{Deserialize, Serialize};
+use tokens::tokens::generic_inference_jobs::InferenceJobToken;
+use tokens::tokens::media_files::MediaFileToken;
+use utoipa::ToSchema;
+
+pub const BYTEDANCE_SEEDREAM_5_LITE_MULTI_FUNCTION_IMAGE_GEN_PATH: &str = "/v1/generate/image/multi_function/bytedance_seedream_5_lite";
+
+#[derive(Serialize, Deserialize, ToSchema)]
+pub struct BytedanceSeedream5LiteMultiFunctionImageGenRequest {
+  /// Idempotency token to prevent duplicate requests.
+  pub uuid_idempotency_token: String,
+
+  /// Text prompt to generate the image from.
+  pub prompt: Option<String>,
+
+  /// Image media tokens to include in the editing context.
+  /// If present, we're doing image editing (image-to-image / image-editing)
+  /// If absent, we're doing image generation (text-to-image)
+  pub image_media_tokens: Option<Vec<MediaFileToken>>,
+
+  /// Number of images to generate. Default is one.
+  pub num_images: Option<BytedanceSeedream5LiteMultiFunctionImageGenNumImages>,
+
+  pub max_images: Option<BytedanceSeedream5LiteMultiFunctionImageGenMaxImages>,
+
+  pub image_size: Option<BytedanceSeedream5LiteMultiFunctionImageGenImageSize>,
+}
+
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, ToSchema)]
+#[serde(rename_all = "snake_case")]
+pub enum BytedanceSeedream5LiteMultiFunctionImageGenNumImages {
+  One, // Default
+  Two,
+  Three,
+  Four,
+}
+
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, ToSchema)]
+#[serde(rename_all = "snake_case")]
+pub enum BytedanceSeedream5LiteMultiFunctionImageGenMaxImages {
+  One, // Default
+  Two,
+  Three,
+  Four,
+}
+
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, ToSchema)]
+#[serde(rename_all = "snake_case")]
+pub enum BytedanceSeedream5LiteMultiFunctionImageGenImageSize {
+  // Square
+  Square,
+  SquareHd,
+  // Tall
+  PortraitFourThree,
+  PortraitSixteenNine,
+  // Wide
+  LandscapeFourThree,
+  LandscapeSixteenNine,
+  // Auto (NB: 5 Lite max is auto_3K, not auto_4K like V4.5)
+  Auto2k,
+  Auto3k,
+}
+
+#[derive(Serialize, Deserialize, ToSchema)]
+pub struct BytedanceSeedream5LiteMultiFunctionImageGenResponse {
+  pub success: bool,
+  pub inference_job_token: InferenceJobToken,
+}

crates/api_clients/artcraft/artcraft_api_defs/src/generate/image/multi_function/mod.rs

@@ -1,5 +1,7 @@
 pub mod bytedance_seedream_v4_multi_function_image_gen;
 pub mod bytedance_seedream_v4p5_multi_function_image_gen;
+pub mod bytedance_seedream_5_lite_multi_function_image_gen;
 pub mod gpt_image_1p5_multi_function_image_gen;
+pub mod nano_banana_2_multi_function_image_gen;
 pub mod nano_banana_multi_function_image_gen;
 pub mod nano_banana_pro_multi_function_image_gen;

crates/api_clients/artcraft/artcraft_api_defs/src/generate/image/multi_function/nano_banana_2_multi_function_image_gen.rs

@@ -0,0 +1,74 @@
+use serde_derive::{Deserialize, Serialize};
+use tokens::tokens::generic_inference_jobs::InferenceJobToken;
+use tokens::tokens::media_files::MediaFileToken;
+use utoipa::ToSchema;
+
+pub const NANO_BANANA_2_MULTI_FUNCTION_IMAGE_GEN_PATH: &str = "/v1/generate/image/multi_function/nano_banana_2";
+
+#[derive(Serialize, Deserialize, ToSchema, Debug)]
+pub struct NanaBanana2MultiFunctionImageGenRequest {
+  /// Idempotency token to prevent duplicate requests.
+  pub uuid_idempotency_token: String,
+
+  /// Text prompt to generate the image from.
+  pub prompt: Option<String>,
+
+  /// Image media tokens to include in the editing context.
+  /// If present, we're doing image editing (image-to-image / image-editing)
+  /// If absent, we're doing image generation (text-to-image)
+  pub image_media_tokens: Option<Vec<MediaFileToken>>,
+
+  /// Number of images to generate. Default is one.
+  pub num_images: Option<NanaBanana2MultiFunctionImageGenNumImages>,
+
+  /// Resolution of the image to generate. Default is OneK (1K).
+  pub resolution: Option<NanaBanana2MultiFunctionImageGenImageResolution>,
+
+  /// Aspect ratio of the images to generate. Default is "1:1"
+  pub aspect_ratio: Option<NanaBanana2MultiFunctionImageGenAspectRatio>,
+}
+
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, ToSchema)]
+#[serde(rename_all = "snake_case")]
+pub enum NanaBanana2MultiFunctionImageGenNumImages {
+  One, // Default
+  Two,
+  Three,
+  Four,
+}
+
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, ToSchema)]
+#[serde(rename_all = "snake_case")]
+pub enum NanaBanana2MultiFunctionImageGenImageResolution {
+  HalfK,
+  OneK,
+  TwoK,
+  FourK,
+}
+
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, ToSchema)]
+#[serde(rename_all = "snake_case")]
+pub enum NanaBanana2MultiFunctionImageGenAspectRatio {
+  // Auto (only for image editing)
+  Auto, // Default for image editing.
+  // Square
+  OneByOne, // Default for text-to-image
+  // Wide
+  FiveByFour,
+  FourByThree,
+  ThreeByTwo,
+  SixteenByNine,
+  TwentyOneByNine,
+  // Tall
+  FourByFive,
+  ThreeByFour,
+  TwoByThree,
+  NineBySixteen,
+}
+
+
+#[derive(Serialize, Deserialize, ToSchema)]
+pub struct NanaBanana2MultiFunctionImageGenResponse {
+  pub success: bool,
+  pub inference_job_token: InferenceJobToken,
+}

crates/api_clients/artcraft/artcraft_api_defs/src/generate/video/multi_function/kling_3p0_pro_multi_function_video_gen.rs

@@ -0,0 +1,66 @@
+use serde::{Deserialize, Serialize};
+use tokens::tokens::generic_inference_jobs::InferenceJobToken;
+use tokens::tokens::media_files::MediaFileToken;
+use utoipa::ToSchema;
+
+pub const KLING_3P0_PRO_MULTI_FUNCTION_VIDEO_PATH: &str = "/v1/generate/video/multi_function/kling_3p0_pro";
+
+/// Both text-to-video and image-to-video in one request.
+#[derive(Serialize, Deserialize, ToSchema)]
+pub struct Kling3p0ProMultiFunctionVideoGenRequest {
+  /// Idempotency token to prevent duplicate requests.
+  pub uuid_idempotency_token: String,
+
+  /// Text prompt.
+  pub prompt: Option<String>,
+
+  /// Optional negative prompt.
+  pub negative_prompt: Option<String>,
+
+  /// If present, we're doing image-to-video. If absent, text-to-video.
+  pub image_media_token: Option<MediaFileToken>,
+
+  /// Optional end frame image.
+  pub end_image_media_token: Option<MediaFileToken>,
+
+  /// Duration of the video (3-15 seconds).
+  pub duration: Option<Kling3p0ProMultiFunctionVideoGenDuration>,
+
+  /// Whether to generate audio.
+  pub generate_audio: Option<bool>,
+
+  /// Aspect ratio (only for text-to-video).
+  pub aspect_ratio: Option<Kling3p0ProMultiFunctionVideoGenAspectRatio>,
+}
+
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, ToSchema)]
+#[serde(rename_all = "snake_case")]
+pub enum Kling3p0ProMultiFunctionVideoGenDuration {
+  ThreeSeconds,
+  FourSeconds,
+  FiveSeconds,
+  SixSeconds,
+  SevenSeconds,
+  EightSeconds,
+  NineSeconds,
+  TenSeconds,
+  ElevenSeconds,
+  TwelveSeconds,
+  ThirteenSeconds,
+  FourteenSeconds,
+  FifteenSeconds,
+}
+
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, ToSchema)]
+#[serde(rename_all = "snake_case")]
+pub enum Kling3p0ProMultiFunctionVideoGenAspectRatio {
+  Square,
+  SixteenByNine,
+  NineBySixteen,
+}
+
+#[derive(Serialize, Deserialize, ToSchema)]
+pub struct Kling3p0ProMultiFunctionVideoGenResponse {
+  pub success: bool,
+  pub inference_job_token: InferenceJobToken,
+}

crates/api_clients/artcraft/artcraft_api_defs/src/generate/video/multi_function/kling_3p0_standard_multi_function_video_gen.rs

@@ -0,0 +1,66 @@
+use serde::{Deserialize, Serialize};
+use tokens::tokens::generic_inference_jobs::InferenceJobToken;
+use tokens::tokens::media_files::MediaFileToken;
+use utoipa::ToSchema;
+
+pub const KLING_3P0_STANDARD_MULTI_FUNCTION_VIDEO_PATH: &str = "/v1/generate/video/multi_function/kling_3p0_standard";
+
+/// Both text-to-video and image-to-video in one request.
+#[derive(Serialize, Deserialize, ToSchema)]
+pub struct Kling3p0StandardMultiFunctionVideoGenRequest {
+  /// Idempotency token to prevent duplicate requests.
+  pub uuid_idempotency_token: String,
+
+  /// Text prompt.
+  pub prompt: Option<String>,
+
+  /// Optional negative prompt.
+  pub negative_prompt: Option<String>,
+
+  /// If present, we're doing image-to-video. If absent, text-to-video.
+  pub image_media_token: Option<MediaFileToken>,
+
+  /// Optional end frame image.
+  pub end_image_media_token: Option<MediaFileToken>,
+
+  /// Duration of the video (3-15 seconds).
+  pub duration: Option<Kling3p0StandardMultiFunctionVideoGenDuration>,
+
+  /// Whether to generate audio.
+  pub generate_audio: Option<bool>,
+
+  /// Aspect ratio (only for text-to-video).
+  pub aspect_ratio: Option<Kling3p0StandardMultiFunctionVideoGenAspectRatio>,
+}
+
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, ToSchema)]
+#[serde(rename_all = "snake_case")]
+pub enum Kling3p0StandardMultiFunctionVideoGenDuration {
+  ThreeSeconds,
+  FourSeconds,
+  FiveSeconds,
+  SixSeconds,
+  SevenSeconds,
+  EightSeconds,
+  NineSeconds,
+  TenSeconds,
+  ElevenSeconds,
+  TwelveSeconds,
+  ThirteenSeconds,
+  FourteenSeconds,
+  FifteenSeconds,
+}
+
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, ToSchema)]
+#[serde(rename_all = "snake_case")]
+pub enum Kling3p0StandardMultiFunctionVideoGenAspectRatio {
+  Square,
+  SixteenByNine,
+  NineBySixteen,
+}
+
+#[derive(Serialize, Deserialize, ToSchema)]
+pub struct Kling3p0StandardMultiFunctionVideoGenResponse {
+  pub success: bool,
+  pub inference_job_token: InferenceJobToken,
+}

crates/api_clients/artcraft/artcraft_api_defs/src/generate/video/multi_function/mod.rs

@@ -1,5 +1,8 @@
 pub mod kling_2_5_turbo_multi_function_video_gen;
 pub mod kling_2_6_multi_function_video_gen;
+pub mod kling_3p0_pro_multi_function_video_gen;
+pub mod kling_3p0_standard_multi_function_video_gen;
+pub mod seedance_1p5_pro_multi_function_video_gen;
 pub mod seedance_2p0_multi_function_video_gen;
 pub mod sora_2_multi_function_video_gen;
 pub mod sora_2_pro_multi_function_video_gen;

crates/api_clients/artcraft/artcraft_api_defs/src/generate/video/multi_function/seedance_1p5_pro_multi_function_video_gen.rs

@@ -0,0 +1,85 @@
+use serde::{Deserialize, Serialize};
+use tokens::tokens::generic_inference_jobs::InferenceJobToken;
+use tokens::tokens::media_files::MediaFileToken;
+use utoipa::ToSchema;
+
+pub const SEEDANCE_1P5_PRO_MULTI_FUNCTION_VIDEO_GEN_PATH: &str = "/v1/generate/video/multi_function/seedance_1p5_pro";
+
+/// Both text-to-video and image-to-video in one request.
+#[derive(Serialize, Deserialize, ToSchema, Debug)]
+pub struct Seedance1p5ProMultiFunctionVideoGenRequest {
+  /// Idempotency token to prevent duplicate requests.
+  pub uuid_idempotency_token: String,
+
+  /// "Required".
+  /// Required downstream, but we'll coerce null to empty string.
+  /// Text prompt.
+  pub prompt: Option<String>,
+
+  /// Optional.
+  /// Only for image-to-video.
+  /// Source of the starting frame.
+  /// If present, we're doing image-to-video.
+  /// If absent, we're doing text-to-video.
+  pub start_frame_image_media_token: Option<MediaFileToken>,
+
+  /// Optional.
+  /// Only for image-to-video.
+  /// Source of the ending frame.
+  pub end_frame_image_media_token: Option<MediaFileToken>,
+
+  /// Optional.
+  pub resolution: Option<Seedance1p5ProMultiFunctionVideoGenResolution>,
+
+  /// Optional.
+  /// Duration of the video.
+  /// (this is uniform against all modes)
+  pub duration: Option<Seedance1p5ProMultiFunctionVideoGenDuration>,
+
+  /// Optional.
+  pub aspect_ratio: Option<Seedance1p5ProMultiFunctionVideoGenAspectRatio>,
+
+  /// Whether to generate audio.
+  pub generate_audio: Option<bool>,
+}
+
+#[derive(Serialize, Deserialize, ToSchema, Copy, Clone, Debug)]
+#[serde(rename_all = "snake_case")]
+pub enum Seedance1p5ProMultiFunctionVideoGenResolution {
+  FourEightyP,
+  SevenTwentyP,
+  TenEightyP,
+}
+
+#[derive(Serialize, Deserialize, ToSchema, Copy, Clone, Debug)]
+#[serde(rename_all = "snake_case")]
+pub enum Seedance1p5ProMultiFunctionVideoGenDuration {
+  FourSeconds,
+  FiveSeconds,
+  SixSeconds,
+  SevenSeconds,
+  EightSeconds,
+  NineSeconds,
+  TenSeconds,
+  ElevenSeconds,
+  TwelveSeconds,
+}
+
+#[derive(Serialize, Deserialize, ToSchema, Copy, Clone, Debug)]
+#[serde(rename_all = "snake_case")]
+pub enum Seedance1p5ProMultiFunctionVideoGenAspectRatio {
+  TwentyOneByNine,
+  SixteenByNine,
+  FourByThree,
+  Square,
+  ThreeByFour,
+  NineBySixteen,
+  Auto,
+}
+
+
+#[derive(Serialize, Deserialize, ToSchema)]
+pub struct Seedance1p5ProMultiFunctionVideoGenResponse {
+  pub success: bool,
+  pub inference_job_token: InferenceJobToken,
+}

crates/api_clients/artcraft/artcraft_api_defs/src/lib.rs

@@ -4,8 +4,10 @@ pub mod credits;
 pub mod generate;
 pub mod jobs;
 pub mod media_file;
+pub mod moderation;
 pub mod prompts;
 pub mod stripe_artcraft;
 pub mod subscriptions;
 pub mod users;
-pub mod utils;
+pub mod utils;
+pub mod web_referrals;

crates/api_clients/artcraft/artcraft_api_defs/src/moderation/jobs/mod.rs

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

crates/api_clients/artcraft/artcraft_api_defs/src/moderation/jobs/user/list_user_jobs.rs

@@ -0,0 +1,33 @@
+use enums::by_table::wallet_ledger_entries::wallet_ledger_entry_type::WalletLedgerEntryType;
+use enums::common::job_status_plus::JobStatusPlus;
+use serde_derive::{Deserialize, Serialize};
+use tokens::tokens::generic_inference_jobs::InferenceJobToken;
+use tokens::tokens::media_files::MediaFileToken;
+use tokens::tokens::users::UserToken;
+use tokens::tokens::wallet_ledger_entries::WalletLedgerEntryToken;
+use utoipa::ToSchema;
+
+pub const LIST_USER_JOBS_PATH: &str = "/v1/moderation/jobs/user/{user_token}/list";
+
+#[derive(Deserialize, ToSchema)]
+pub struct ListUserJobsPathInfo {
+  pub user_token: UserToken,
+}
+
+#[derive(Serialize, ToSchema)]
+pub struct ListUserJobsResponse {
+  pub success: bool,
+  pub jobs: Vec<ListUserJobsEntry>,
+}
+
+#[derive(Serialize, ToSchema)]
+pub struct ListUserJobsEntry {
+  pub job_status: JobStatusPlus,
+  pub job_failure_reason: Option<String>,
+  pub credits_delta: Option<i32>,
+  pub maybe_linked_refund_ledger_token: Option<WalletLedgerEntryToken>,
+  pub on_success_result_media_token: Option<MediaFileToken>,
+  pub job_token: InferenceJobToken,
+  pub wallet_ledger_entry_token: Option<WalletLedgerEntryToken>,
+  pub wallet_ledger_entry_type: Option<WalletLedgerEntryType>,
+}

crates/api_clients/artcraft/artcraft_api_defs/src/moderation/jobs/user/mod.rs

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

crates/api_clients/artcraft/artcraft_api_defs/src/moderation/mod.rs

@@ -0,0 +1,4 @@
+pub mod jobs;
+pub mod user;
+pub mod wallet_ledger_entries;
+pub mod wallets;

crates/api_clients/artcraft/artcraft_api_defs/src/moderation/user/mod.rs

@@ -0,0 +1,2 @@
+pub mod user_lookup;
+pub mod user_lookup_by_stripe_customer_id;

crates/api_clients/artcraft/artcraft_api_defs/src/moderation/user/user_lookup.rs

@@ -0,0 +1,39 @@
+use chrono::{DateTime, Utc};
+use serde_derive::{Deserialize, Serialize};
+use tokens::tokens::media_files::MediaFileToken;
+use tokens::tokens::users::UserToken;
+use utoipa::ToSchema;
+
+pub const MODERATOR_USER_LOOKUP_PATH: &str = "/v1/moderation/users/lookup";
+
+#[derive(Deserialize, ToSchema)]
+pub struct ModeratorUserLookupRequest {
+  pub search: String,
+}
+
+#[derive(Serialize, ToSchema)]
+pub struct ModeratorUserLookupSuccessResponse {
+  pub success: bool,
+  pub maybe_user: Option<ModeratorUserLookupUserDetails>,
+}
+
+#[derive(Serialize, ToSchema)]
+pub struct ModeratorUserLookupUserDetails {
+  pub token: UserToken,
+  pub username: String,
+  pub display_name: String,
+  pub username_is_generated: bool,
+  pub is_temporary: bool,
+  pub username_is_not_customized: bool,
+  pub email_address: String,
+  pub email_confirmed: bool,
+  pub email_is_synthetic: bool,
+  pub is_without_password: bool,
+  pub ip_address_creation: String,
+  pub ip_address_last_login: String,
+  pub maybe_avatar_media_file_token: Option<MediaFileToken>,
+  pub email_gravatar_hash: String,
+  pub is_banned: bool,
+  pub created_at: DateTime<Utc>,
+  pub updated_at: DateTime<Utc>,
+}

crates/api_clients/artcraft/artcraft_api_defs/src/moderation/user/user_lookup_by_stripe_customer_id.rs

@@ -0,0 +1,27 @@
+use enums::common::payments_namespace::PaymentsNamespace;
+use serde_derive::{Deserialize, Serialize};
+use tokens::tokens::users::UserToken;
+use utoipa::ToSchema;
+
+pub const MODERATOR_USER_LOOKUP_BY_STRIPE_CUSTOMER_ID_PATH: &str = "/v1/moderation/users/lookup_by_stripe_customer_id";
+
+#[derive(Deserialize, ToSchema)]
+pub struct ModeratorUserLookupByStripeCustomerIdRequest {
+  pub stripe_customer_id: String,
+}
+
+#[derive(Serialize, ToSchema)]
+pub struct ModeratorUserLookupByStripeCustomerIdResponse {
+  pub success: bool,
+  pub users: Vec<ModeratorUserLookupByStripeCustomerIdEntry>,
+}
+
+#[derive(Serialize, ToSchema)]
+pub struct ModeratorUserLookupByStripeCustomerIdEntry {
+  pub subscription_namespace: PaymentsNamespace,
+  pub maybe_stripe_subscription_id: Option<String>,
+  pub token: UserToken,
+  pub email_address: String,
+  pub username: String,
+  pub display_name: String,
+}

crates/api_clients/artcraft/artcraft_api_defs/src/moderation/wallet_ledger_entries/list_wallet_ledger_entries_by_wallet.rs

@@ -0,0 +1,35 @@
+use chrono::{DateTime, Utc};
+use enums::by_table::wallet_ledger_entries::wallet_ledger_entry_type::WalletLedgerEntryType;
+use serde_derive::{Deserialize, Serialize};
+use tokens::tokens::wallet_ledger_entries::WalletLedgerEntryToken;
+use tokens::tokens::wallets::WalletToken;
+use utoipa::ToSchema;
+
+pub const LIST_WALLET_LEDGER_ENTRIES_BY_WALLET_PATH: &str = "/v1/moderation/wallet_ledger_entries/wallet/{wallet_token}/list";
+
+#[derive(Deserialize, ToSchema)]
+pub struct ListWalletLedgerEntriesByWalletPathInfo {
+  pub wallet_token: WalletToken,
+}
+
+#[derive(Serialize, ToSchema)]
+pub struct ListWalletLedgerEntriesByWalletResponse {
+  pub success: bool,
+  pub entries: Vec<ListWalletLedgerEntriesByWalletEntry>,
+}
+
+#[derive(Serialize, ToSchema)]
+pub struct ListWalletLedgerEntriesByWalletEntry {
+  pub token: WalletLedgerEntryToken,
+  pub wallet_token: WalletToken,
+  pub entry_type: WalletLedgerEntryType,
+  pub maybe_entity_ref: Option<String>,
+  pub credits_delta: i32,
+  pub banked_credits_before: u32,
+  pub banked_credits_after: u32,
+  pub monthly_credits_before: u32,
+  pub monthly_credits_after: u32,
+  pub created_at: DateTime<Utc>,
+  pub is_refunded: bool,
+  pub maybe_linked_refund_ledger_token: Option<WalletLedgerEntryToken>,
+}

crates/api_clients/artcraft/artcraft_api_defs/src/moderation/wallet_ledger_entries/mod.rs

@@ -0,0 +1,2 @@
+pub mod list_wallet_ledger_entries_by_wallet;
+pub mod moderator_get_wallet_ledger_entry;

crates/api_clients/artcraft/artcraft_api_defs/src/moderation/wallet_ledger_entries/moderator_get_wallet_ledger_entry.rs

@@ -0,0 +1,33 @@
+use chrono::{DateTime, Utc};
+use enums::by_table::wallet_ledger_entries::wallet_ledger_entry_type::WalletLedgerEntryType;
+use serde_derive::{Deserialize, Serialize};
+use tokens::tokens::wallet_ledger_entries::WalletLedgerEntryToken;
+use utoipa::ToSchema;
+
+pub const MODERATOR_GET_WALLET_LEDGER_ENTRY_PATH: &str = "/v1/moderation/wallet_ledger_entry/{wallet_ledger_entry_token}";
+
+#[derive(Deserialize, ToSchema)]
+pub struct ModeratorGetWalletLedgerEntryPathInfo {
+  pub wallet_ledger_entry_token: WalletLedgerEntryToken,
+}
+
+#[derive(Serialize, ToSchema)]
+pub struct ModeratorGetWalletLedgerEntryResponse {
+  pub success: bool,
+  pub maybe_entry: Option<ModeratorGetWalletLedgerEntryDetails>,
+}
+
+#[derive(Serialize, ToSchema)]
+pub struct ModeratorGetWalletLedgerEntryDetails {
+  pub token: WalletLedgerEntryToken,
+  pub entry_type: WalletLedgerEntryType,
+  pub maybe_entity_ref: Option<String>,
+  pub credits_delta: i32,
+  pub banked_credits_before: u32,
+  pub banked_credits_after: u32,
+  pub monthly_credits_before: u32,
+  pub monthly_credits_after: u32,
+  pub is_refunded: bool,
+  pub maybe_linked_refund_ledger_token: Option<WalletLedgerEntryToken>,
+  pub created_at: DateTime<Utc>,
+}

crates/api_clients/artcraft/artcraft_api_defs/src/moderation/wallets/list_user_wallets.rs

@@ -0,0 +1,30 @@
+use chrono::{DateTime, Utc};
+use enums::common::payments_namespace::PaymentsNamespace;
+use serde_derive::{Deserialize, Serialize};
+use tokens::tokens::users::UserToken;
+use tokens::tokens::wallets::WalletToken;
+use utoipa::ToSchema;
+
+pub const LIST_USER_WALLETS_PATH: &str = "/v1/moderation/wallets/user/{user_token}/list";
+
+#[derive(Deserialize, ToSchema)]
+pub struct ListUserWalletsPathInfo {
+  pub user_token: UserToken,
+}
+
+#[derive(Serialize, ToSchema)]
+pub struct ListUserWalletsResponse {
+  pub success: bool,
+  pub wallets: Vec<ListUserWalletsEntry>,
+}
+
+#[derive(Serialize, ToSchema)]
+pub struct ListUserWalletsEntry {
+  pub token: WalletToken,
+  pub wallet_namespace: PaymentsNamespace,
+  pub banked_credits: u32,
+  pub monthly_credits: u32,
+  pub version: i32,
+  pub created_at: DateTime<Utc>,
+  pub updated_at: DateTime<Utc>,
+}

crates/api_clients/artcraft/artcraft_api_defs/src/moderation/wallets/mod.rs

@@ -0,0 +1,3 @@
+pub mod list_user_wallets;
+pub mod moderator_add_banked_balance_to_wallet;
+pub mod moderator_get_wallet;

crates/api_clients/artcraft/artcraft_api_defs/src/moderation/wallets/moderator_add_banked_balance_to_wallet.rs

@@ -0,0 +1,20 @@
+use serde_derive::{Deserialize, Serialize};
+use tokens::tokens::wallets::WalletToken;
+use utoipa::ToSchema;
+
+pub const MODERATOR_ADD_BANKED_BALANCE_TO_WALLET_PATH: &str = "/v1/moderation/wallet/{wallet_token}/add_banked_balance";
+
+#[derive(Deserialize, ToSchema)]
+pub struct ModeratorAddBankedBalanceToWalletPathInfo {
+  pub wallet_token: WalletToken,
+}
+
+#[derive(Deserialize, ToSchema)]
+pub struct ModeratorAddBankedBalanceToWalletRequest {
+  pub credits: u16,
+}
+
+#[derive(Serialize, ToSchema)]
+pub struct ModeratorAddBankedBalanceToWalletResponse {
+  pub success: bool,
+}

crates/api_clients/artcraft/artcraft_api_defs/src/moderation/wallets/moderator_get_wallet.rs

@@ -0,0 +1,31 @@
+use chrono::{DateTime, Utc};
+use enums::common::payments_namespace::PaymentsNamespace;
+use serde_derive::{Deserialize, Serialize};
+use tokens::tokens::users::UserToken;
+use tokens::tokens::wallets::WalletToken;
+use utoipa::ToSchema;
+
+pub const MODERATOR_GET_WALLET_PATH: &str = "/v1/moderation/wallet/{wallet_token}";
+
+#[derive(Deserialize, ToSchema)]
+pub struct ModeratorGetWalletPathInfo {
+  pub wallet_token: WalletToken,
+}
+
+#[derive(Serialize, ToSchema)]
+pub struct ModeratorGetWalletResponse {
+  pub success: bool,
+  pub maybe_wallet: Option<ModeratorGetWalletDetails>,
+}
+
+#[derive(Serialize, ToSchema)]
+pub struct ModeratorGetWalletDetails {
+  pub token: WalletToken,
+  pub wallet_namespace: PaymentsNamespace,
+  pub owner_user_token: UserToken,
+  pub banked_credits: u32,
+  pub monthly_credits: u32,
+  pub version: i32,
+  pub created_at: DateTime<Utc>,
+  pub updated_at: DateTime<Utc>,
+}

crates/api_clients/artcraft/artcraft_api_defs/src/stripe_artcraft/create_create_new_user_account_and_subscription_checkout.rs

@@ -11,6 +11,11 @@ pub struct StripeArtcraftCreateSubscriptionCheckoutWithUserSignupRequest {
   pub plan: Option<ArtcraftSubscriptionSlug>,
 
   pub cadence: Option<PlanBillingCadence>,
+
+  /// Optional: The referral URL the user arrived from when signing up.
+  /// The browser can send `document.referrer` to the backend so we know how people are finding us.
+  /// If the browser doesn't send this parameter, we'll try the `referer` header.
+  pub maybe_referral_url: Option<String>,
 }
 
 #[derive(Serialize, Deserialize, ToSchema, Debug, Copy, Clone)]

crates/api_clients/artcraft/artcraft_api_defs/src/web_referrals/log_web_referral.rs

@@ -0,0 +1,17 @@
+use serde_derive::{Deserialize, Serialize};
+use utoipa::ToSchema;
+
+pub const LOG_WEB_REFERRAL_URL_PATH: &str = "/v1/web_referrals/record";
+
+#[derive(Deserialize, ToSchema)]
+pub struct LogWebReferralRequest {
+  /// Optional: The referral URL the user arrived from when signing up.
+  /// The browser can send `document.referrer` to the backend so we know how people are finding us.
+  /// If the browser doesn't send this parameter, we'll try the `referer` header.
+  pub maybe_referral_url: Option<String>,
+}
+
+#[derive(Serialize, ToSchema)]
+pub struct LogWebReferralResponse {
+  pub success: bool,
+}

crates/api_clients/artcraft/artcraft_api_defs/src/web_referrals/mod.rs

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

crates/api_clients/artcraft/artcraft_client/src/endpoints/generate/image/multi_function/bytedance_seedream_5_lite_multi_function_image_gen_image.rs

@@ -0,0 +1,18 @@
+use crate::credentials::storyteller_credential_set::StorytellerCredentialSet;
+use crate::error::storyteller_error::StorytellerError;
+use crate::utils::api_host::ApiHost;
+use crate::utils::basic_json_post_request::basic_json_post_request;
+use artcraft_api_defs::generate::image::multi_function::bytedance_seedream_5_lite_multi_function_image_gen::{BytedanceSeedream5LiteMultiFunctionImageGenRequest, BytedanceSeedream5LiteMultiFunctionImageGenResponse, BYTEDANCE_SEEDREAM_5_LITE_MULTI_FUNCTION_IMAGE_GEN_PATH};
+
+pub async fn bytedance_seedream_5_lite_multi_function_image_gen(
+  api_host: &ApiHost,
+  maybe_creds: Option<&StorytellerCredentialSet>,
+  request: BytedanceSeedream5LiteMultiFunctionImageGenRequest,
+) -> Result<BytedanceSeedream5LiteMultiFunctionImageGenResponse, StorytellerError> {
+  Ok(basic_json_post_request(
+    api_host,
+    BYTEDANCE_SEEDREAM_5_LITE_MULTI_FUNCTION_IMAGE_GEN_PATH,
+    maybe_creds,
+    request,
+  ).await?)
+}

crates/api_clients/artcraft/artcraft_client/src/endpoints/generate/image/multi_function/mod.rs

@@ -1,5 +1,7 @@
 pub mod bytedance_seedream_v4_multi_function_image_gen_image;
 pub mod bytedance_seedream_v4p5_multi_function_image_gen_image;
+pub mod bytedance_seedream_5_lite_multi_function_image_gen_image;
 pub mod gpt_image_1p5_multi_function_image_gen_image;
+pub mod nano_banana_2_multi_function_image_gen_image;
 pub mod nano_banana_multi_function_image_gen_image;
 pub mod nano_banana_pro_multi_function_image_gen_image;

crates/api_clients/artcraft/artcraft_client/src/endpoints/generate/image/multi_function/nano_banana_2_multi_function_image_gen_image.rs

@@ -0,0 +1,18 @@
+use crate::credentials::storyteller_credential_set::StorytellerCredentialSet;
+use crate::error::storyteller_error::StorytellerError;
+use crate::utils::api_host::ApiHost;
+use crate::utils::basic_json_post_request::basic_json_post_request;
+use artcraft_api_defs::generate::image::multi_function::nano_banana_2_multi_function_image_gen::{NanaBanana2MultiFunctionImageGenRequest, NanaBanana2MultiFunctionImageGenResponse, NANO_BANANA_2_MULTI_FUNCTION_IMAGE_GEN_PATH};
+
+pub async fn nano_banana_2_multi_function_image_gen(
+  api_host: &ApiHost,
+  maybe_creds: Option<&StorytellerCredentialSet>,
+  request: NanaBanana2MultiFunctionImageGenRequest,
+) -> Result<NanaBanana2MultiFunctionImageGenResponse, StorytellerError> {
+  Ok(basic_json_post_request(
+    api_host,
+    NANO_BANANA_2_MULTI_FUNCTION_IMAGE_GEN_PATH,
+    maybe_creds,
+    request,
+  ).await?)
+}

crates/api_clients/artcraft/artcraft_client/src/endpoints/generate/video/multi_function/kling_3p0_pro_multi_function_video_gen.rs

@@ -0,0 +1,18 @@
+use crate::credentials::storyteller_credential_set::StorytellerCredentialSet;
+use crate::error::storyteller_error::StorytellerError;
+use crate::utils::api_host::ApiHost;
+use crate::utils::basic_json_post_request::basic_json_post_request;
+use artcraft_api_defs::generate::video::multi_function::kling_3p0_pro_multi_function_video_gen::{Kling3p0ProMultiFunctionVideoGenRequest, Kling3p0ProMultiFunctionVideoGenResponse, KLING_3P0_PRO_MULTI_FUNCTION_VIDEO_PATH};
+
+pub async fn kling_3p0_pro_multi_function_video_gen(
+  api_host: &ApiHost,
+  maybe_creds: Option<&StorytellerCredentialSet>,
+  request: Kling3p0ProMultiFunctionVideoGenRequest,
+) -> Result<Kling3p0ProMultiFunctionVideoGenResponse, StorytellerError> {
+  Ok(basic_json_post_request(
+    api_host,
+    KLING_3P0_PRO_MULTI_FUNCTION_VIDEO_PATH,
+    maybe_creds,
+    request,
+  ).await?)
+}

crates/api_clients/artcraft/artcraft_client/src/endpoints/generate/video/multi_function/kling_3p0_standard_multi_function_video_gen.rs

@@ -0,0 +1,18 @@
+use crate::credentials::storyteller_credential_set::StorytellerCredentialSet;
+use crate::error::storyteller_error::StorytellerError;
+use crate::utils::api_host::ApiHost;
+use crate::utils::basic_json_post_request::basic_json_post_request;
+use artcraft_api_defs::generate::video::multi_function::kling_3p0_standard_multi_function_video_gen::{Kling3p0StandardMultiFunctionVideoGenRequest, Kling3p0StandardMultiFunctionVideoGenResponse, KLING_3P0_STANDARD_MULTI_FUNCTION_VIDEO_PATH};
+
+pub async fn kling_3p0_standard_multi_function_video_gen(
+  api_host: &ApiHost,
+  maybe_creds: Option<&StorytellerCredentialSet>,
+  request: Kling3p0StandardMultiFunctionVideoGenRequest,
+) -> Result<Kling3p0StandardMultiFunctionVideoGenResponse, StorytellerError> {
+  Ok(basic_json_post_request(
+    api_host,
+    KLING_3P0_STANDARD_MULTI_FUNCTION_VIDEO_PATH,
+    maybe_creds,
+    request,
+  ).await?)
+}

crates/api_clients/artcraft/artcraft_client/src/endpoints/generate/video/multi_function/mod.rs

@@ -1,6 +1,9 @@
 pub mod kling_2p5_turbo_pro_multi_function_video_gen;
+pub mod seedance_1p5_pro_multi_function_video_gen;
 pub mod seedance_2p0_multi_function_video_gen;
 pub mod kling_2p6_pro_multi_function_video_gen;
+pub mod kling_3p0_pro_multi_function_video_gen;
+pub mod kling_3p0_standard_multi_function_video_gen;
 pub mod sora_2_multi_function_video_gen;
 pub mod sora_2_pro_multi_function_video_gen;
 pub mod veo_3p1_fast_multi_function_video_gen;

crates/api_clients/artcraft/artcraft_client/src/endpoints/generate/video/multi_function/seedance_1p5_pro_multi_function_video_gen.rs

@@ -0,0 +1,18 @@
+use crate::credentials::storyteller_credential_set::StorytellerCredentialSet;
+use crate::error::storyteller_error::StorytellerError;
+use crate::utils::api_host::ApiHost;
+use crate::utils::basic_json_post_request::basic_json_post_request;
+use artcraft_api_defs::generate::video::multi_function::seedance_1p5_pro_multi_function_video_gen::{Seedance1p5ProMultiFunctionVideoGenRequest, Seedance1p5ProMultiFunctionVideoGenResponse, SEEDANCE_1P5_PRO_MULTI_FUNCTION_VIDEO_GEN_PATH};
+
+pub async fn seedance_1p5_pro_multi_function_video_gen(
+  api_host: &ApiHost,
+  maybe_creds: Option<&StorytellerCredentialSet>,
+  request: Seedance1p5ProMultiFunctionVideoGenRequest,
+) -> Result<Seedance1p5ProMultiFunctionVideoGenResponse, StorytellerError> {
+  Ok(basic_json_post_request(
+    api_host,
+    SEEDANCE_1P5_PRO_MULTI_FUNCTION_VIDEO_GEN_PATH,
+    maybe_creds,
+    request,
+  ).await?)
+}

crates/api_clients/artcraft/artcraft_router/Cargo.toml

@@ -32,3 +32,5 @@ uuid.workspace = true
 
 [dev-dependencies]
 test_data.workspace = true
+strum.workspace = true
+

crates/api_clients/artcraft/artcraft_router/src/api/common_aspect_ratio.rs

@@ -1,9 +1,12 @@
 use serde_derive::{Deserialize, Serialize};
+#[cfg(test)]
+use strum::EnumIter;
 
 /// This is a comprehensive list of common aspect ratios you can specify when enqueuing a generation.
 /// Not every model will support every aspect ratio.
 /// In the case a model doesn't support the aspect ratio, gracefully pick the nearest option.
 #[derive(Copy, Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(test, derive(EnumIter))]
 #[serde(rename_all = "snake_case")]
 pub enum CommonAspectRatio {
   // Auto (eg. for image editing to use the source; used by Nano Banana Pro edit image, but not text-to-image)

crates/api_clients/artcraft/artcraft_router/src/api/common_image_model.rs

@@ -5,6 +5,26 @@ use serde_derive::{Deserialize, Serialize};
 #[derive(Copy, Clone, Debug, Serialize, Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum CommonImageModel {
+  #[serde(rename = "flux_1_dev")]
+  Flux1Dev,
+  #[serde(rename = "flux_1_schnell")]
+  Flux1Schnell,
+  #[serde(rename = "flux_pro_1p1")]
+  FluxPro11,
+  #[serde(rename = "flux_pro_1p1_ultra")]
+  FluxPro11Ultra,
+  #[serde(rename = "gpt_image_1p5")]
+  GptImage1p5,
+  #[serde(rename = "nano_banana")]
+  NanaBanana,
+  #[serde(rename = "nano_banana_2")]
+  NanaBanana2,
   #[serde(rename = "nano_banana_pro")]
   NanaBananaPro,
+  #[serde(rename = "seedream_4")]
+  Seedream4,
+  #[serde(rename = "seedream_4p5")]
+  Seedream4p5,
+  #[serde(rename = "seedream_5_lite")]
+  Seedream5Lite,
 }

crates/api_clients/artcraft/artcraft_router/src/api/common_video_model.rs

@@ -23,9 +23,18 @@ pub enum CommonVideoModel {
   #[serde(rename = "kling_2p6_pro")]
   Kling2p6Pro,
 
+  #[serde(rename = "kling_3p0_standard")]
+  Kling3p0Standard,
+
+  #[serde(rename = "kling_3p0_pro")]
+  Kling3p0Pro,
+
   #[serde(rename = "seedance_1p0_lite")]
   Seedance10Lite,
 
+  #[serde(rename = "seedance_1p5_pro")]
+  Seedance1p5Pro,
+
   #[serde(rename = "seedance_2p0")]
   Seedance2p0,
 

crates/api_clients/artcraft/artcraft_router/src/client/generation_mode_mismatch_strategy.rs

@@ -0,0 +1,12 @@
+
+/// Strategy for handling requests where the model only supports text-to-image
+/// but the request includes image inputs (image editing mode).
+#[derive(Copy, Clone, Debug)]
+pub enum GenerationModeMismatchStrategy {
+  /// Abort the generation: return an error if image inputs are provided
+  /// for a text-to-image-only model.
+  AbortGeneration,
+
+  /// Proceed anyway, ignoring the image inputs for the generation.
+  GenerateAnyway,
+}

crates/api_clients/artcraft/artcraft_router/src/client/mod.rs

@@ -1,3 +1,4 @@
+pub mod generation_mode_mismatch_strategy;
 pub mod multi_router_client;
 pub mod multi_router_client_builder;
 pub mod request_mismatch_mitigation_strategy;

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/cost/artcraft/estimate_image_cost_artcraft_flux_1_dev.rs

@@ -0,0 +1,66 @@
+use artcraft_api_defs::generate::image::text::generate_flux_1_dev_text_to_image::GenerateFlux1DevTextToImageNumImages;
+
+use crate::generate::generate_image::image_generation_cost_estimate::ImageGenerationCostEstimate;
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_flux_1_dev::PlanArtcraftFlux1Dev;
+
+pub(crate) fn estimate_image_cost_artcraft_flux_1_dev(
+  plan: &PlanArtcraftFlux1Dev<'_>,
+) -> ImageGenerationCostEstimate {
+  // Pricing: $0.02/image (2 cents). 1 credit = 1 USD cent.
+  let cost_per_image: u64 = 2;
+
+  let num_images: u64 = match plan.num_images {
+    GenerateFlux1DevTextToImageNumImages::One => 1,
+    GenerateFlux1DevTextToImageNumImages::Two => 2,
+    GenerateFlux1DevTextToImageNumImages::Three => 3,
+    GenerateFlux1DevTextToImageNumImages::Four => 4,
+  };
+
+  let cost_in_usd_cents = cost_per_image * num_images;
+
+  ImageGenerationCostEstimate {
+    cost_in_credits: Some(cost_in_usd_cents),
+    cost_in_usd_cents: Some(cost_in_usd_cents),
+    is_free: false,
+    is_unlimited: false,
+    is_rate_limited: false,
+    has_watermark: false,
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use crate::api::common_image_model::CommonImageModel;
+  use crate::api::provider::Provider;
+  use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+  use crate::generate::generate_image::generate_image_request::GenerateImageRequest;
+
+  fn estimate_usd_cents(image_batch_count: u16) -> u64 {
+    let request = GenerateImageRequest {
+      model: CommonImageModel::Flux1Dev,
+      provider: Provider::Artcraft,
+      prompt: None,
+      image_inputs: None,
+      resolution: None,
+      aspect_ratio: None,
+      image_batch_count: Some(image_batch_count),
+      request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+      generation_mode_mismatch_strategy: None,
+      idempotency_token: None,
+    };
+    request.build()
+      .expect("build should succeed")
+      .estimate_costs()
+      .cost_in_usd_cents
+      .expect("cost_in_usd_cents should be present")
+  }
+
+  #[test]
+  fn test_estimate_cost_usd_cents() {
+    // $0.02/image = 2 cents each
+    assert_eq!(estimate_usd_cents(1), 2);
+    assert_eq!(estimate_usd_cents(2), 4);
+    assert_eq!(estimate_usd_cents(3), 6);
+    assert_eq!(estimate_usd_cents(4), 8);
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/cost/artcraft/estimate_image_cost_artcraft_flux_1_schnell.rs

@@ -0,0 +1,45 @@
+use crate::generate::generate_image::image_generation_cost_estimate::ImageGenerationCostEstimate;
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_flux_1_schnell::PlanArtcraftFlux1Schnell;
+
+pub(crate) fn estimate_image_cost_artcraft_flux_1_schnell(
+  _plan: &PlanArtcraftFlux1Schnell<'_>,
+) -> ImageGenerationCostEstimate {
+  // Pricing: not available
+  ImageGenerationCostEstimate {
+    cost_in_credits: None,
+    cost_in_usd_cents: None,
+    is_free: true,
+    is_unlimited: true,
+    is_rate_limited: false,
+    has_watermark: false,
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use crate::api::common_image_model::CommonImageModel;
+  use crate::api::provider::Provider;
+  use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+  use crate::generate::generate_image::generate_image_request::GenerateImageRequest;
+
+  #[test]
+  fn test_estimate_cost_is_none() {
+    let request = GenerateImageRequest {
+      model: CommonImageModel::Flux1Schnell,
+      provider: Provider::Artcraft,
+      prompt: None,
+      image_inputs: None,
+      resolution: None,
+      aspect_ratio: None,
+      image_batch_count: Some(1),
+      request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+      generation_mode_mismatch_strategy: None,
+      idempotency_token: None,
+    };
+    let estimate = request.build()
+      .expect("build should succeed")
+      .estimate_costs();
+    assert!(estimate.cost_in_usd_cents.is_none());
+    assert!(estimate.cost_in_credits.is_none());
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/cost/artcraft/estimate_image_cost_artcraft_flux_pro_1p1.rs

@@ -0,0 +1,66 @@
+use artcraft_api_defs::generate::image::text::generate_flux_pro_11_text_to_image::GenerateFluxPro11TextToImageNumImages;
+
+use crate::generate::generate_image::image_generation_cost_estimate::ImageGenerationCostEstimate;
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_flux_pro_1p1::PlanArtcraftFluxPro11;
+
+pub(crate) fn estimate_image_cost_artcraft_flux_pro_1p1(
+  plan: &PlanArtcraftFluxPro11<'_>,
+) -> ImageGenerationCostEstimate {
+  // NB(bt): Slightly more than 3 cents, weird megapixel maths. We can eat that cost for now.
+  let cost_per_image: u64 = 3;
+
+  let num_images: u64 = match plan.num_images {
+    GenerateFluxPro11TextToImageNumImages::One => 1,
+    GenerateFluxPro11TextToImageNumImages::Two => 2,
+    GenerateFluxPro11TextToImageNumImages::Three => 3,
+    GenerateFluxPro11TextToImageNumImages::Four => 4,
+  };
+
+  let cost_in_usd_cents = cost_per_image * num_images;
+
+  ImageGenerationCostEstimate {
+    cost_in_credits: Some(cost_in_usd_cents),
+    cost_in_usd_cents: Some(cost_in_usd_cents),
+    is_free: false,
+    is_unlimited: false,
+    is_rate_limited: false,
+    has_watermark: false,
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use crate::api::common_image_model::CommonImageModel;
+  use crate::api::provider::Provider;
+  use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+  use crate::generate::generate_image::generate_image_request::GenerateImageRequest;
+
+  fn estimate_usd_cents(image_batch_count: u16) -> u64 {
+    let request = GenerateImageRequest {
+      model: CommonImageModel::FluxPro11,
+      provider: Provider::Artcraft,
+      prompt: None,
+      image_inputs: None,
+      resolution: None,
+      aspect_ratio: None,
+      image_batch_count: Some(image_batch_count),
+      request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+      generation_mode_mismatch_strategy: None,
+      idempotency_token: None,
+    };
+    request.build()
+      .expect("build should succeed")
+      .estimate_costs()
+      .cost_in_usd_cents
+      .expect("cost_in_usd_cents should be present")
+  }
+
+  #[test]
+  fn test_estimate_cost_usd_cents() {
+    // ~$0.03/image = 3 cents each (slightly more than 3¢ actual, rounded up)
+    assert_eq!(estimate_usd_cents(1), 3);
+    assert_eq!(estimate_usd_cents(2), 6);
+    assert_eq!(estimate_usd_cents(3), 9);
+    assert_eq!(estimate_usd_cents(4), 12);
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/cost/artcraft/estimate_image_cost_artcraft_flux_pro_1p1_ultra.rs

@@ -0,0 +1,66 @@
+use artcraft_api_defs::generate::image::text::generate_flux_pro_11_ultra_text_to_image::GenerateFluxPro11UltraTextToImageNumImages;
+
+use crate::generate::generate_image::image_generation_cost_estimate::ImageGenerationCostEstimate;
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_flux_pro_1p1_ultra::PlanArtcraftFluxPro11Ultra;
+
+pub(crate) fn estimate_image_cost_artcraft_flux_pro_1p1_ultra(
+  plan: &PlanArtcraftFluxPro11Ultra<'_>,
+) -> ImageGenerationCostEstimate {
+  // Pricing: $0.06/image (6 cents). 1 credit = 1 USD cent.
+  let cost_per_image: u64 = 6;
+
+  let num_images: u64 = match plan.num_images {
+    GenerateFluxPro11UltraTextToImageNumImages::One => 1,
+    GenerateFluxPro11UltraTextToImageNumImages::Two => 2,
+    GenerateFluxPro11UltraTextToImageNumImages::Three => 3,
+    GenerateFluxPro11UltraTextToImageNumImages::Four => 4,
+  };
+
+  let cost_in_usd_cents = cost_per_image * num_images;
+
+  ImageGenerationCostEstimate {
+    cost_in_credits: Some(cost_in_usd_cents),
+    cost_in_usd_cents: Some(cost_in_usd_cents),
+    is_free: false,
+    is_unlimited: false,
+    is_rate_limited: false,
+    has_watermark: false,
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use crate::api::common_image_model::CommonImageModel;
+  use crate::api::provider::Provider;
+  use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+  use crate::generate::generate_image::generate_image_request::GenerateImageRequest;
+
+  fn estimate_usd_cents(image_batch_count: u16) -> u64 {
+    let request = GenerateImageRequest {
+      model: CommonImageModel::FluxPro11Ultra,
+      provider: Provider::Artcraft,
+      prompt: None,
+      image_inputs: None,
+      resolution: None,
+      aspect_ratio: None,
+      image_batch_count: Some(image_batch_count),
+      request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+      generation_mode_mismatch_strategy: None,
+      idempotency_token: None,
+    };
+    request.build()
+      .expect("build should succeed")
+      .estimate_costs()
+      .cost_in_usd_cents
+      .expect("cost_in_usd_cents should be present")
+  }
+
+  #[test]
+  fn test_estimate_cost_usd_cents() {
+    // $0.06/image = 6 cents each
+    assert_eq!(estimate_usd_cents(1), 6);
+    assert_eq!(estimate_usd_cents(2), 12);
+    assert_eq!(estimate_usd_cents(3), 18);
+    assert_eq!(estimate_usd_cents(4), 24);
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/cost/artcraft/estimate_image_cost_artcraft_gpt_image_1p5.rs

@@ -0,0 +1,120 @@
+use artcraft_api_defs::generate::image::multi_function::gpt_image_1p5_multi_function_image_gen::{
+  GptImage1p5MultiFunctionImageGenNumImages, GptImage1p5MultiFunctionImageGenQuality,
+  GptImage1p5MultiFunctionImageGenSize,
+};
+
+use crate::generate::generate_image::image_generation_cost_estimate::ImageGenerationCostEstimate;
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_gpt_image_1p5::PlanArtcraftGptImage1p5;
+
+pub(crate) fn estimate_image_cost_artcraft_gpt_image_1p5(
+  plan: &PlanArtcraftGptImage1p5<'_>,
+) -> ImageGenerationCostEstimate {
+  // Pricing varies by quality and image size. 1 credit = 1 USD cent.
+  // Low:    $0.01/image (any size)
+  // Medium: $0.03/image (square/unset), $0.05/image (wide or tall)
+  // High:   $0.13/image (square/unset), $0.20/image (wide or tall)
+  //
+  // From Fal (text to image) -
+  //
+  // Your request will cost different amounts based on the number of images, quality, and size.
+  //
+  //     You will be charged $0.005 per 1,000 input text tokens. One word is roughly 4 tokens.
+  //     You will be charged $0.010 per 1,000 output text tokens. The model will consume tokens reasoning about your prompt based on it's complexity.
+  //     For low quality, you will be charged $0.009 for 1024x1024 or $0.013 for any other size per image.
+  //     For medium quality, you will be charged $0.034 for 1024x1024, $0.051 for 1024x1536 and $0.050 for 1536x1024 per image.
+  //     For high quality, you will be charged $0.133 for 1024x1024, $0.200 for 1024x1536 or $0.199 for 1536x1024 per image.
+  //
+  // From Fal (image to image) -
+  //
+  // Your request will cost different amounts based on the number of images, quality, and size.
+  //
+  //     You will be charged $0.005 per 1,000 input text tokens. One word is roughly 4 tokens.
+  //     You will be charged $0.008 per 1,000 input image tokens. One 1024x1024 image is roughly 135 tokens in low fidelity mode, or 3,050 tokens in high fidelity mode.
+  //     You will be charged $0.010 per 1,000 output text tokens. The model will consume tokens reasoning about your prompt based on it's complexity.
+  //     For low quality, you will be charged $0.009 for 1024x1024 or $0.013 for any other size per image.
+  //     For medium quality, you will be charged $0.034 for 1024x1024, $0.051 for 1024x1536 and $0.050 for 1536x1024 per image.
+  //     For high quality, you will be charged $0.133 for 1024x1024, $0.200 for 1024x1536 or $0.199 for 1536x1024 per image.
+  //
+  let cost_per_image: u64 = match plan.quality {
+    GptImage1p5MultiFunctionImageGenQuality::Low => 1,
+    GptImage1p5MultiFunctionImageGenQuality::Medium => match plan.image_size {
+      Some(GptImage1p5MultiFunctionImageGenSize::Square) | None => 3,
+      Some(GptImage1p5MultiFunctionImageGenSize::Wide) | Some(GptImage1p5MultiFunctionImageGenSize::Tall) => 5,
+    },
+    GptImage1p5MultiFunctionImageGenQuality::High => match plan.image_size {
+      Some(GptImage1p5MultiFunctionImageGenSize::Square) | None => 13,
+      Some(GptImage1p5MultiFunctionImageGenSize::Wide) | Some(GptImage1p5MultiFunctionImageGenSize::Tall) => 20,
+    },
+  };
+
+  let num_images: u64 = match plan.num_images {
+    GptImage1p5MultiFunctionImageGenNumImages::One => 1,
+    GptImage1p5MultiFunctionImageGenNumImages::Two => 2,
+    GptImage1p5MultiFunctionImageGenNumImages::Three => 3,
+    GptImage1p5MultiFunctionImageGenNumImages::Four => 4,
+  };
+
+  let cost_in_usd_cents = cost_per_image * num_images;
+
+  ImageGenerationCostEstimate {
+    cost_in_credits: Some(cost_in_usd_cents),
+    cost_in_usd_cents: Some(cost_in_usd_cents),
+    is_free: false,
+    is_unlimited: false,
+    is_rate_limited: false,
+    has_watermark: false,
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use crate::api::common_aspect_ratio::CommonAspectRatio;
+  use crate::api::common_image_model::CommonImageModel;
+  use crate::api::provider::Provider;
+  use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+  use crate::generate::generate_image::generate_image_request::GenerateImageRequest;
+
+  fn estimate_usd_cents(image_batch_count: u16, aspect_ratio: Option<CommonAspectRatio>) -> u64 {
+    let request = GenerateImageRequest {
+      model: CommonImageModel::GptImage1p5,
+      provider: Provider::Artcraft,
+      prompt: None,
+      image_inputs: None,
+      resolution: None,
+      aspect_ratio,
+      image_batch_count: Some(image_batch_count),
+      request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+      generation_mode_mismatch_strategy: None,
+      idempotency_token: None,
+    };
+    request.build()
+      .expect("build should succeed")
+      .estimate_costs()
+      .cost_in_usd_cents
+      .expect("cost_in_usd_cents should be present")
+  }
+
+  #[test]
+  fn test_estimate_cost_medium_square() {
+    // Default quality (Medium) + square/unset size = 3 cents each
+    assert_eq!(estimate_usd_cents(1, None), 3);
+    assert_eq!(estimate_usd_cents(1, Some(CommonAspectRatio::Square)), 3);
+    assert_eq!(estimate_usd_cents(2, Some(CommonAspectRatio::Square)), 6);
+    assert_eq!(estimate_usd_cents(3, Some(CommonAspectRatio::Square)), 9);
+    assert_eq!(estimate_usd_cents(4, Some(CommonAspectRatio::Square)), 12);
+  }
+
+  #[test]
+  fn test_estimate_cost_medium_wide() {
+    // Medium + wide = 5 cents each
+    assert_eq!(estimate_usd_cents(1, Some(CommonAspectRatio::WideSixteenByNine)), 5);
+    assert_eq!(estimate_usd_cents(4, Some(CommonAspectRatio::WideSixteenByNine)), 20);
+  }
+
+  #[test]
+  fn test_estimate_cost_medium_tall() {
+    // Medium + tall = 5 cents each
+    assert_eq!(estimate_usd_cents(1, Some(CommonAspectRatio::TallNineBySixteen)), 5);
+    assert_eq!(estimate_usd_cents(4, Some(CommonAspectRatio::TallNineBySixteen)), 20);
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/cost/artcraft/estimate_image_cost_artcraft_nano_banana.rs

@@ -0,0 +1,66 @@
+use artcraft_api_defs::generate::image::multi_function::nano_banana_multi_function_image_gen::NanoBananaMultiFunctionImageGenNumImages;
+
+use crate::generate::generate_image::image_generation_cost_estimate::ImageGenerationCostEstimate;
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_nano_banana::PlanArtcraftNanaBanana;
+
+pub(crate) fn estimate_image_cost_artcraft_nano_banana(
+  plan: &PlanArtcraftNanaBanana<'_>,
+) -> ImageGenerationCostEstimate {
+  // Pricing: $0.04/image (4 cents). 1 credit = 1 USD cent.
+  let cost_per_image: u64 = 4;
+
+  let num_images: u64 = match plan.num_images {
+    NanoBananaMultiFunctionImageGenNumImages::One => 1,
+    NanoBananaMultiFunctionImageGenNumImages::Two => 2,
+    NanoBananaMultiFunctionImageGenNumImages::Three => 3,
+    NanoBananaMultiFunctionImageGenNumImages::Four => 4,
+  };
+
+  let cost_in_usd_cents = cost_per_image * num_images;
+
+  ImageGenerationCostEstimate {
+    cost_in_credits: Some(cost_in_usd_cents),
+    cost_in_usd_cents: Some(cost_in_usd_cents),
+    is_free: false,
+    is_unlimited: false,
+    is_rate_limited: false,
+    has_watermark: false,
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use crate::api::common_image_model::CommonImageModel;
+  use crate::api::provider::Provider;
+  use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+  use crate::generate::generate_image::generate_image_request::GenerateImageRequest;
+
+  fn estimate_usd_cents(image_batch_count: u16) -> u64 {
+    let request = GenerateImageRequest {
+      model: CommonImageModel::NanaBanana,
+      provider: Provider::Artcraft,
+      prompt: None,
+      image_inputs: None,
+      resolution: None,
+      aspect_ratio: None,
+      image_batch_count: Some(image_batch_count),
+      request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+      generation_mode_mismatch_strategy: None,
+      idempotency_token: None,
+    };
+    request.build()
+      .expect("build should succeed")
+      .estimate_costs()
+      .cost_in_usd_cents
+      .expect("cost_in_usd_cents should be present")
+  }
+
+  #[test]
+  fn test_estimate_cost_usd_cents() {
+    // $0.04/image = 4 cents each
+    assert_eq!(estimate_usd_cents(1), 4);
+    assert_eq!(estimate_usd_cents(2), 8);
+    assert_eq!(estimate_usd_cents(3), 12);
+    assert_eq!(estimate_usd_cents(4), 16);
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/cost/artcraft/estimate_image_cost_artcraft_nano_banana_2.rs

@@ -0,0 +1,79 @@
+use artcraft_api_defs::generate::image::multi_function::nano_banana_2_multi_function_image_gen::{
+  NanaBanana2MultiFunctionImageGenImageResolution, NanaBanana2MultiFunctionImageGenNumImages,
+};
+
+use crate::generate::generate_image::image_generation_cost_estimate::ImageGenerationCostEstimate;
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_nano_banana_2::PlanArtcraftNanaBanana2;
+
+pub(crate) fn estimate_image_cost_artcraft_nano_banana_2(
+  plan: &PlanArtcraftNanaBanana2<'_>,
+) -> ImageGenerationCostEstimate {
+  // Pricing: $0.08/image at 0.5K, $0.15/image at 1K or 2K, $0.30/image at 4K.
+  // (Stored as USD cents.)
+  let cost_per_image: u64 = match plan.resolution {
+    Some(NanaBanana2MultiFunctionImageGenImageResolution::HalfK) => 8,
+    Some(NanaBanana2MultiFunctionImageGenImageResolution::FourK) => 30,
+    _ => 15, // OneK, TwoK, or None (default 1K)
+  };
+
+  let num_images: u64 = match plan.num_images {
+    NanaBanana2MultiFunctionImageGenNumImages::One => 1,
+    NanaBanana2MultiFunctionImageGenNumImages::Two => 2,
+    NanaBanana2MultiFunctionImageGenNumImages::Three => 3,
+    NanaBanana2MultiFunctionImageGenNumImages::Four => 4,
+  };
+
+  let cost_in_usd_cents = cost_per_image * num_images;
+
+  ImageGenerationCostEstimate {
+    cost_in_credits: Some(cost_in_usd_cents),
+    cost_in_usd_cents: Some(cost_in_usd_cents),
+    is_free: false,
+    is_unlimited: false,
+    is_rate_limited: false,
+    has_watermark: false,
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use crate::api::common_image_model::CommonImageModel;
+  use crate::api::common_resolution::CommonResolution;
+  use crate::api::provider::Provider;
+  use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+  use crate::generate::generate_image::generate_image_request::GenerateImageRequest;
+
+  fn estimate_usd_cents(resolution: Option<CommonResolution>, image_batch_count: u16) -> u64 {
+    let request = GenerateImageRequest {
+      model: CommonImageModel::NanaBanana2,
+      provider: Provider::Artcraft,
+      prompt: None,
+      image_inputs: None,
+      resolution,
+      aspect_ratio: None,
+      image_batch_count: Some(image_batch_count),
+      request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+      generation_mode_mismatch_strategy: None,
+      idempotency_token: None,
+    };
+    request.build()
+      .expect("build should succeed")
+      .estimate_costs()
+      .cost_in_usd_cents
+      .expect("cost_in_usd_cents should be present")
+  }
+
+  #[test]
+  fn test_estimate_cost_usd_cents() {
+    // 1K/2K: $0.15/image = 15 cents
+    assert_eq!(estimate_usd_cents(None, 1), 15);
+    assert_eq!(estimate_usd_cents(Some(CommonResolution::OneK), 1), 15);
+    assert_eq!(estimate_usd_cents(Some(CommonResolution::TwoK), 1), 15);
+    assert_eq!(estimate_usd_cents(Some(CommonResolution::OneK), 2), 30);
+    assert_eq!(estimate_usd_cents(Some(CommonResolution::OneK), 4), 60);
+
+    // 4K: $0.30/image = 30 cents
+    assert_eq!(estimate_usd_cents(Some(CommonResolution::FourK), 1), 30);
+    assert_eq!(estimate_usd_cents(Some(CommonResolution::FourK), 2), 60);
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/cost/artcraft/estimate_image_cost_artcraft_nano_banana_pro.rs

@@ -52,6 +52,7 @@ mod tests {
       aspect_ratio: None,
       image_batch_count: Some(image_batch_count),
       request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+      generation_mode_mismatch_strategy: None,
       idempotency_token: None,
     };
     request.build()

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/cost/artcraft/estimate_image_cost_artcraft_seedream_4.rs

@@ -0,0 +1,66 @@
+use artcraft_api_defs::generate::image::multi_function::bytedance_seedream_v4_multi_function_image_gen::BytedanceSeedreamV4MultiFunctionImageGenNumImages;
+
+use crate::generate::generate_image::image_generation_cost_estimate::ImageGenerationCostEstimate;
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_seedream_4::PlanArtcraftSeedream4;
+
+pub(crate) fn estimate_image_cost_artcraft_seedream_4(
+  plan: &PlanArtcraftSeedream4<'_>,
+) -> ImageGenerationCostEstimate {
+  // Pricing: $0.03/image (3 cents). 1 credit = 1 USD cent.
+  let cost_per_image: u64 = 3;
+
+  let num_images: u64 = match plan.num_images {
+    BytedanceSeedreamV4MultiFunctionImageGenNumImages::One => 1,
+    BytedanceSeedreamV4MultiFunctionImageGenNumImages::Two => 2,
+    BytedanceSeedreamV4MultiFunctionImageGenNumImages::Three => 3,
+    BytedanceSeedreamV4MultiFunctionImageGenNumImages::Four => 4,
+  };
+
+  let cost_in_usd_cents = cost_per_image * num_images;
+
+  ImageGenerationCostEstimate {
+    cost_in_credits: Some(cost_in_usd_cents),
+    cost_in_usd_cents: Some(cost_in_usd_cents),
+    is_free: false,
+    is_unlimited: false,
+    is_rate_limited: false,
+    has_watermark: false,
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use crate::api::common_image_model::CommonImageModel;
+  use crate::api::provider::Provider;
+  use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+  use crate::generate::generate_image::generate_image_request::GenerateImageRequest;
+
+  fn estimate_usd_cents(image_batch_count: u16) -> u64 {
+    let request = GenerateImageRequest {
+      model: CommonImageModel::Seedream4,
+      provider: Provider::Artcraft,
+      prompt: None,
+      image_inputs: None,
+      resolution: None,
+      aspect_ratio: None,
+      image_batch_count: Some(image_batch_count),
+      request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+      generation_mode_mismatch_strategy: None,
+      idempotency_token: None,
+    };
+    request.build()
+      .expect("build should succeed")
+      .estimate_costs()
+      .cost_in_usd_cents
+      .expect("cost_in_usd_cents should be present")
+  }
+
+  #[test]
+  fn test_estimate_cost_usd_cents() {
+    // $0.03/image = 3 cents each
+    assert_eq!(estimate_usd_cents(1), 3);
+    assert_eq!(estimate_usd_cents(2), 6);
+    assert_eq!(estimate_usd_cents(3), 9);
+    assert_eq!(estimate_usd_cents(4), 12);
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/cost/artcraft/estimate_image_cost_artcraft_seedream_4p5.rs

@@ -0,0 +1,66 @@
+use artcraft_api_defs::generate::image::multi_function::bytedance_seedream_v4p5_multi_function_image_gen::BytedanceSeedreamV4p5MultiFunctionImageGenNumImages;
+
+use crate::generate::generate_image::image_generation_cost_estimate::ImageGenerationCostEstimate;
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_seedream_4p5::PlanArtcraftSeedream4p5;
+
+pub(crate) fn estimate_image_cost_artcraft_seedream_4p5(
+  plan: &PlanArtcraftSeedream4p5<'_>,
+) -> ImageGenerationCostEstimate {
+  // Pricing: $0.04/image (4 cents). 1 credit = 1 USD cent.
+  let cost_per_image: u64 = 4;
+
+  let num_images: u64 = match plan.num_images {
+    BytedanceSeedreamV4p5MultiFunctionImageGenNumImages::One => 1,
+    BytedanceSeedreamV4p5MultiFunctionImageGenNumImages::Two => 2,
+    BytedanceSeedreamV4p5MultiFunctionImageGenNumImages::Three => 3,
+    BytedanceSeedreamV4p5MultiFunctionImageGenNumImages::Four => 4,
+  };
+
+  let cost_in_usd_cents = cost_per_image * num_images;
+
+  ImageGenerationCostEstimate {
+    cost_in_credits: Some(cost_in_usd_cents),
+    cost_in_usd_cents: Some(cost_in_usd_cents),
+    is_free: false,
+    is_unlimited: false,
+    is_rate_limited: false,
+    has_watermark: false,
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use crate::api::common_image_model::CommonImageModel;
+  use crate::api::provider::Provider;
+  use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+  use crate::generate::generate_image::generate_image_request::GenerateImageRequest;
+
+  fn estimate_usd_cents(image_batch_count: u16) -> u64 {
+    let request = GenerateImageRequest {
+      model: CommonImageModel::Seedream4p5,
+      provider: Provider::Artcraft,
+      prompt: None,
+      image_inputs: None,
+      resolution: None,
+      aspect_ratio: None,
+      image_batch_count: Some(image_batch_count),
+      request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+      generation_mode_mismatch_strategy: None,
+      idempotency_token: None,
+    };
+    request.build()
+      .expect("build should succeed")
+      .estimate_costs()
+      .cost_in_usd_cents
+      .expect("cost_in_usd_cents should be present")
+  }
+
+  #[test]
+  fn test_estimate_cost_usd_cents() {
+    // $0.04/image = 4 cents each
+    assert_eq!(estimate_usd_cents(1), 4);
+    assert_eq!(estimate_usd_cents(2), 8);
+    assert_eq!(estimate_usd_cents(3), 12);
+    assert_eq!(estimate_usd_cents(4), 16);
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/cost/artcraft/estimate_image_cost_artcraft_seedream_5_lite.rs

@@ -0,0 +1,66 @@
+use artcraft_api_defs::generate::image::multi_function::bytedance_seedream_5_lite_multi_function_image_gen::BytedanceSeedream5LiteMultiFunctionImageGenNumImages;
+
+use crate::generate::generate_image::image_generation_cost_estimate::ImageGenerationCostEstimate;
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_seedream_5_lite::PlanArtcraftSeedream5Lite;
+
+pub(crate) fn estimate_image_cost_artcraft_seedream_5_lite(
+  plan: &PlanArtcraftSeedream5Lite<'_>,
+) -> ImageGenerationCostEstimate {
+  // Pricing: $0.04/image (4 cents). 1 credit = 1 USD cent.
+  let cost_per_image: u64 = 4;
+
+  let num_images: u64 = match plan.num_images {
+    BytedanceSeedream5LiteMultiFunctionImageGenNumImages::One => 1,
+    BytedanceSeedream5LiteMultiFunctionImageGenNumImages::Two => 2,
+    BytedanceSeedream5LiteMultiFunctionImageGenNumImages::Three => 3,
+    BytedanceSeedream5LiteMultiFunctionImageGenNumImages::Four => 4,
+  };
+
+  let cost_in_usd_cents = cost_per_image * num_images;
+
+  ImageGenerationCostEstimate {
+    cost_in_credits: Some(cost_in_usd_cents),
+    cost_in_usd_cents: Some(cost_in_usd_cents),
+    is_free: false,
+    is_unlimited: false,
+    is_rate_limited: false,
+    has_watermark: false,
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use crate::api::common_image_model::CommonImageModel;
+  use crate::api::provider::Provider;
+  use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+  use crate::generate::generate_image::generate_image_request::GenerateImageRequest;
+
+  fn estimate_usd_cents(image_batch_count: u16) -> u64 {
+    let request = GenerateImageRequest {
+      model: CommonImageModel::Seedream5Lite,
+      provider: Provider::Artcraft,
+      prompt: None,
+      image_inputs: None,
+      resolution: None,
+      aspect_ratio: None,
+      image_batch_count: Some(image_batch_count),
+      request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+      generation_mode_mismatch_strategy: None,
+      idempotency_token: None,
+    };
+    request.build()
+      .expect("build should succeed")
+      .estimate_costs()
+      .cost_in_usd_cents
+      .expect("cost_in_usd_cents should be present")
+  }
+
+  #[test]
+  fn test_estimate_cost_usd_cents() {
+    // $0.04/image = 4 cents each
+    assert_eq!(estimate_usd_cents(1), 4);
+    assert_eq!(estimate_usd_cents(2), 8);
+    assert_eq!(estimate_usd_cents(3), 12);
+    assert_eq!(estimate_usd_cents(4), 16);
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/cost/artcraft/mod.rs

@@ -1 +1,11 @@
+pub mod estimate_image_cost_artcraft_flux_1_dev;
+pub mod estimate_image_cost_artcraft_flux_1_schnell;
+pub mod estimate_image_cost_artcraft_flux_pro_1p1;
+pub mod estimate_image_cost_artcraft_flux_pro_1p1_ultra;
+pub mod estimate_image_cost_artcraft_gpt_image_1p5;
+pub mod estimate_image_cost_artcraft_nano_banana;
+pub mod estimate_image_cost_artcraft_nano_banana_2;
 pub mod estimate_image_cost_artcraft_nano_banana_pro;
+pub mod estimate_image_cost_artcraft_seedream_4;
+pub mod estimate_image_cost_artcraft_seedream_4p5;
+pub mod estimate_image_cost_artcraft_seedream_5_lite;

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/cost/fal/estimate_image_cost_fal_nano_banana_pro.rs

@@ -50,6 +50,7 @@ mod tests {
       aspect_ratio: None,
       image_batch_count: Some(image_batch_count),
       request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+      generation_mode_mismatch_strategy: None,
       idempotency_token: None,
     };
     request.build()

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/execute/artcraft/generate_image_artcraft_flux_1_dev.rs

@@ -0,0 +1,116 @@
+use crate::client::router_artcraft_client::RouterArtcraftClient;
+use crate::errors::artcraft_router_error::ArtcraftRouterError;
+use crate::errors::provider_error::ProviderError;
+use crate::generate::generate_image::generate_image_response::{
+  ArtcraftImageResponsePayload, GenerateImageResponse,
+};
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_flux_1_dev::PlanArtcraftFlux1Dev;
+use artcraft_api_defs::generate::image::text::generate_flux_1_dev_text_to_image::GenerateFlux1DevTextToImageRequest;
+use artcraft_client::endpoints::generate::image::text::generate_flux_1_dev_text_to_image::generate_flux_1_dev_text_to_image;
+
+pub async fn execute_artcraft_flux_1_dev(
+  plan: &PlanArtcraftFlux1Dev<'_>,
+  artcraft_client: &RouterArtcraftClient,
+) -> Result<GenerateImageResponse, ArtcraftRouterError> {
+  let request = GenerateFlux1DevTextToImageRequest {
+    uuid_idempotency_token: plan.idempotency_token.clone(),
+    prompt: plan.prompt.map(|p| p.to_string()),
+    aspect_ratio: plan.aspect_ratio,
+    num_images: Some(plan.num_images),
+  };
+
+  let response = generate_flux_1_dev_text_to_image(
+    &artcraft_client.api_host,
+    Some(&artcraft_client.credentials),
+    request,
+  )
+    .await
+    .map_err(|err| ArtcraftRouterError::Provider(ProviderError::Storyteller(err)))?;
+
+  Ok(GenerateImageResponse::Artcraft(ArtcraftImageResponsePayload {
+    inference_job_token: response.inference_job_token,
+  }))
+}
+
+#[cfg(test)]
+mod tests {
+  use crate::api::common_aspect_ratio::CommonAspectRatio;
+  use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+  use crate::generate::generate_image::generate_image_request::GenerateImageRequest;
+  use crate::generate::generate_image::image_generation_plan::ImageGenerationPlan;
+  use crate::test_helpers::{base_flux_1_dev_image_request, get_artcraft_client};
+  use strum::IntoEnumIterator;
+
+  #[tokio::test]
+  #[ignore] // manually run — fires a real API request and incurs cost
+  async fn test_text_to_image_flux_1_dev() {
+    let client = get_artcraft_client();
+    let request = GenerateImageRequest {
+      aspect_ratio: Some(CommonAspectRatio::WideSixteenByNine),
+      image_batch_count: Some(1),
+      prompt: Some("a cat walking through a cyberpunk city at night"),
+      ..base_flux_1_dev_image_request()
+    };
+
+    let plan = request.build().unwrap();
+    let result = plan.generate_image(&client).await;
+
+    println!("Result: {:?}", result);
+    let response = result.expect("generate_image request failed");
+    let payload = response.get_artcraft_payload().expect("expected Artcraft payload");
+    println!("Job token: {:?}", payload.inference_job_token);
+
+    assert_eq!(1, 2); // NB: Intentional failure to inspect the response above.
+  }
+
+  #[tokio::test]
+  #[ignore] // manually run — fires a real API request and incurs cost
+  async fn test_text_to_image_flux_1_dev_batch_four() {
+    let client = get_artcraft_client();
+    let request = GenerateImageRequest {
+      aspect_ratio: Some(CommonAspectRatio::Square),
+      image_batch_count: Some(4),
+      prompt: Some("a dog surfing a wave, cinematic"),
+      ..base_flux_1_dev_image_request()
+    };
+
+    let plan = request.build().unwrap();
+    let result = plan.generate_image(&client).await;
+
+    println!("Result: {:?}", result);
+    let response = result.expect("generate_image request failed");
+    let payload = response.get_artcraft_payload().expect("expected Artcraft payload");
+    println!("Job token: {:?}", payload.inference_job_token);
+
+    assert_eq!(1, 2); // NB: Intentional failure to inspect the response above.
+  }
+
+  #[tokio::test]
+  #[ignore] // manually run — fires one real API request per aspect ratio variant (expensive)
+  async fn test_text_to_image_flux_1_dev_all_aspect_ratios() {
+    let client = get_artcraft_client();
+
+    for ar in CommonAspectRatio::iter() {
+      println!("--- text-to-image aspect ratio: {:?} ---", ar);
+      let request = GenerateImageRequest {
+        aspect_ratio: Some(ar),
+        image_batch_count: Some(1),
+        prompt: Some("a bear walking through an abandoned desert city at night"),
+        request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::PayMoreUpgrade,
+        ..base_flux_1_dev_image_request()
+      };
+      match request.build() {
+        Err(e) => println!("  plan error: {:?}", e),
+        Ok(plan) => match plan.generate_image(&client).await {
+          Ok(response) => {
+            let payload = response.get_artcraft_payload().expect("expected Artcraft payload");
+            println!("  job token: {:?}", payload.inference_job_token);
+          }
+          Err(e) => println!("  generate error: {:?}", e),
+        },
+      }
+    }
+
+    assert_eq!(1, 2); // NB: Intentional failure to inspect the responses above.
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/execute/artcraft/generate_image_artcraft_flux_1_schnell.rs

@@ -0,0 +1,116 @@
+use crate::client::router_artcraft_client::RouterArtcraftClient;
+use crate::errors::artcraft_router_error::ArtcraftRouterError;
+use crate::errors::provider_error::ProviderError;
+use crate::generate::generate_image::generate_image_response::{
+  ArtcraftImageResponsePayload, GenerateImageResponse,
+};
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_flux_1_schnell::PlanArtcraftFlux1Schnell;
+use artcraft_api_defs::generate::image::text::generate_flux_1_schnell_text_to_image::GenerateFlux1SchnellTextToImageRequest;
+use artcraft_client::endpoints::generate::image::text::generate_flux_1_schnell_text_to_image::generate_flux_1_schnell_text_to_image;
+
+pub async fn execute_artcraft_flux_1_schnell(
+  plan: &PlanArtcraftFlux1Schnell<'_>,
+  artcraft_client: &RouterArtcraftClient,
+) -> Result<GenerateImageResponse, ArtcraftRouterError> {
+  let request = GenerateFlux1SchnellTextToImageRequest {
+    uuid_idempotency_token: plan.idempotency_token.clone(),
+    prompt: plan.prompt.map(|p| p.to_string()),
+    aspect_ratio: plan.aspect_ratio,
+    num_images: Some(plan.num_images),
+  };
+
+  let response = generate_flux_1_schnell_text_to_image(
+    &artcraft_client.api_host,
+    Some(&artcraft_client.credentials),
+    request,
+  )
+    .await
+    .map_err(|err| ArtcraftRouterError::Provider(ProviderError::Storyteller(err)))?;
+
+  Ok(GenerateImageResponse::Artcraft(ArtcraftImageResponsePayload {
+    inference_job_token: response.inference_job_token,
+  }))
+}
+
+#[cfg(test)]
+mod tests {
+  use crate::api::common_aspect_ratio::CommonAspectRatio;
+  use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+  use crate::generate::generate_image::generate_image_request::GenerateImageRequest;
+  use crate::generate::generate_image::image_generation_plan::ImageGenerationPlan;
+  use crate::test_helpers::{base_flux_1_schnell_image_request, get_artcraft_client};
+  use strum::IntoEnumIterator;
+
+  #[tokio::test]
+  #[ignore] // manually run — fires a real API request and incurs cost
+  async fn test_text_to_image_flux_1_schnell() {
+    let client = get_artcraft_client();
+    let request = GenerateImageRequest {
+      aspect_ratio: Some(CommonAspectRatio::WideSixteenByNine),
+      image_batch_count: Some(1),
+      prompt: Some("a man and woman walking through a cyberpunk city at night"),
+      ..base_flux_1_schnell_image_request()
+    };
+
+    let plan = request.build().unwrap();
+    let result = plan.generate_image(&client).await;
+
+    println!("Result: {:?}", result);
+    let response = result.expect("generate_image request failed");
+    let payload = response.get_artcraft_payload().expect("expected Artcraft payload");
+    println!("Job token: {:?}", payload.inference_job_token);
+
+    assert_eq!(1, 2); // NB: Intentional failure to inspect the response above.
+  }
+
+  #[tokio::test]
+  #[ignore] // manually run — fires a real API request and incurs cost
+  async fn test_text_to_image_flux_1_schnell_batch_four() {
+    let client = get_artcraft_client();
+    let request = GenerateImageRequest {
+      aspect_ratio: Some(CommonAspectRatio::Square),
+      image_batch_count: Some(4),
+      prompt: Some("a dog surfing a wave, cinematic"),
+      ..base_flux_1_schnell_image_request()
+    };
+
+    let plan = request.build().unwrap();
+    let result = plan.generate_image(&client).await;
+
+    println!("Result: {:?}", result);
+    let response = result.expect("generate_image request failed");
+    let payload = response.get_artcraft_payload().expect("expected Artcraft payload");
+    println!("Job token: {:?}", payload.inference_job_token);
+
+    assert_eq!(1, 2); // NB: Intentional failure to inspect the response above.
+  }
+
+  #[tokio::test]
+  #[ignore] // manually run — fires one real API request per aspect ratio variant (expensive)
+  async fn test_text_to_image_flux_1_schnell_all_aspect_ratios() {
+    let client = get_artcraft_client();
+
+    for ar in CommonAspectRatio::iter() {
+      println!("--- text-to-image aspect ratio: {:?} ---", ar);
+      let request = GenerateImageRequest {
+        aspect_ratio: Some(ar),
+        image_batch_count: Some(1),
+        prompt: Some("a man and woman walking through a futuristic city at evening"),
+        request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::PayMoreUpgrade,
+        ..base_flux_1_schnell_image_request()
+      };
+      match request.build() {
+        Err(e) => println!("  plan error: {:?}", e),
+        Ok(plan) => match plan.generate_image(&client).await {
+          Ok(response) => {
+            let payload = response.get_artcraft_payload().expect("expected Artcraft payload");
+            println!("  job token: {:?}", payload.inference_job_token);
+          }
+          Err(e) => println!("  generate error: {:?}", e),
+        },
+      }
+    }
+
+    assert_eq!(1, 2); // NB: Intentional failure to inspect the responses above.
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/execute/artcraft/generate_image_artcraft_flux_pro_1p1.rs

@@ -0,0 +1,116 @@
+use crate::client::router_artcraft_client::RouterArtcraftClient;
+use crate::errors::artcraft_router_error::ArtcraftRouterError;
+use crate::errors::provider_error::ProviderError;
+use crate::generate::generate_image::generate_image_response::{
+  ArtcraftImageResponsePayload, GenerateImageResponse,
+};
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_flux_pro_1p1::PlanArtcraftFluxPro11;
+use artcraft_api_defs::generate::image::text::generate_flux_pro_11_text_to_image::GenerateFluxPro11TextToImageRequest;
+use artcraft_client::endpoints::generate::image::text::generate_flux_pro_11_text_to_image::generate_flux_pro_11_text_to_image;
+
+pub async fn execute_artcraft_flux_pro_1p1(
+  plan: &PlanArtcraftFluxPro11<'_>,
+  artcraft_client: &RouterArtcraftClient,
+) -> Result<GenerateImageResponse, ArtcraftRouterError> {
+  let request = GenerateFluxPro11TextToImageRequest {
+    uuid_idempotency_token: plan.idempotency_token.clone(),
+    prompt: plan.prompt.map(|p| p.to_string()),
+    aspect_ratio: plan.aspect_ratio,
+    num_images: Some(plan.num_images),
+  };
+
+  let response = generate_flux_pro_11_text_to_image(
+    &artcraft_client.api_host,
+    Some(&artcraft_client.credentials),
+    request,
+  )
+    .await
+    .map_err(|err| ArtcraftRouterError::Provider(ProviderError::Storyteller(err)))?;
+
+  Ok(GenerateImageResponse::Artcraft(ArtcraftImageResponsePayload {
+    inference_job_token: response.inference_job_token,
+  }))
+}
+
+#[cfg(test)]
+mod tests {
+  use crate::api::common_aspect_ratio::CommonAspectRatio;
+  use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+  use crate::generate::generate_image::generate_image_request::GenerateImageRequest;
+  use crate::generate::generate_image::image_generation_plan::ImageGenerationPlan;
+  use crate::test_helpers::{base_flux_pro_1p1_image_request, get_artcraft_client};
+  use strum::IntoEnumIterator;
+
+  #[tokio::test]
+  #[ignore] // manually run — fires a real API request and incurs cost
+  async fn test_text_to_image_flux_pro_1p1() {
+    let client = get_artcraft_client();
+    let request = GenerateImageRequest {
+      aspect_ratio: Some(CommonAspectRatio::WideSixteenByNine),
+      image_batch_count: Some(1),
+      prompt: Some("a cat walking through a cyberpunk city at night"),
+      ..base_flux_pro_1p1_image_request()
+    };
+
+    let plan = request.build().unwrap();
+    let result = plan.generate_image(&client).await;
+
+    println!("Result: {:?}", result);
+    let response = result.expect("generate_image request failed");
+    let payload = response.get_artcraft_payload().expect("expected Artcraft payload");
+    println!("Job token: {:?}", payload.inference_job_token);
+
+    assert_eq!(1, 2); // NB: Intentional failure to inspect the response above.
+  }
+
+  #[tokio::test]
+  #[ignore] // manually run — fires a real API request and incurs cost
+  async fn test_text_to_image_flux_pro_1p1_batch_four() {
+    let client = get_artcraft_client();
+    let request = GenerateImageRequest {
+      aspect_ratio: Some(CommonAspectRatio::Square),
+      image_batch_count: Some(4),
+      prompt: Some("a dog surfing a wave, cinematic"),
+      ..base_flux_pro_1p1_image_request()
+    };
+
+    let plan = request.build().unwrap();
+    let result = plan.generate_image(&client).await;
+
+    println!("Result: {:?}", result);
+    let response = result.expect("generate_image request failed");
+    let payload = response.get_artcraft_payload().expect("expected Artcraft payload");
+    println!("Job token: {:?}", payload.inference_job_token);
+
+    assert_eq!(1, 2); // NB: Intentional failure to inspect the response above.
+  }
+
+  #[tokio::test]
+  #[ignore] // manually run — fires one real API request per aspect ratio variant (expensive)
+  async fn test_text_to_image_flux_pro_1p1_all_aspect_ratios() {
+    let client = get_artcraft_client();
+
+    for ar in CommonAspectRatio::iter() {
+      println!("--- text-to-image aspect ratio: {:?} ---", ar);
+      let request = GenerateImageRequest {
+        aspect_ratio: Some(ar),
+        image_batch_count: Some(1),
+        prompt: Some("a bear walking through an abandoned desert city at night"),
+        request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::PayMoreUpgrade,
+        ..base_flux_pro_1p1_image_request()
+      };
+      match request.build() {
+        Err(e) => println!("  plan error: {:?}", e),
+        Ok(plan) => match plan.generate_image(&client).await {
+          Ok(response) => {
+            let payload = response.get_artcraft_payload().expect("expected Artcraft payload");
+            println!("  job token: {:?}", payload.inference_job_token);
+          }
+          Err(e) => println!("  generate error: {:?}", e),
+        },
+      }
+    }
+
+    assert_eq!(1, 2); // NB: Intentional failure to inspect the responses above.
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/execute/artcraft/generate_image_artcraft_flux_pro_1p1_ultra.rs

@@ -0,0 +1,116 @@
+use crate::client::router_artcraft_client::RouterArtcraftClient;
+use crate::errors::artcraft_router_error::ArtcraftRouterError;
+use crate::errors::provider_error::ProviderError;
+use crate::generate::generate_image::generate_image_response::{
+  ArtcraftImageResponsePayload, GenerateImageResponse,
+};
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_flux_pro_1p1_ultra::PlanArtcraftFluxPro11Ultra;
+use artcraft_api_defs::generate::image::text::generate_flux_pro_11_ultra_text_to_image::GenerateFluxPro11UltraTextToImageRequest;
+use artcraft_client::endpoints::generate::image::text::generate_flux_pro_11_ultra_text_to_image::generate_flux_pro_11_ultra_text_to_image;
+
+pub async fn execute_artcraft_flux_pro_1p1_ultra(
+  plan: &PlanArtcraftFluxPro11Ultra<'_>,
+  artcraft_client: &RouterArtcraftClient,
+) -> Result<GenerateImageResponse, ArtcraftRouterError> {
+  let request = GenerateFluxPro11UltraTextToImageRequest {
+    uuid_idempotency_token: plan.idempotency_token.clone(),
+    prompt: plan.prompt.map(|p| p.to_string()),
+    aspect_ratio: plan.aspect_ratio,
+    num_images: Some(plan.num_images),
+  };
+
+  let response = generate_flux_pro_11_ultra_text_to_image(
+    &artcraft_client.api_host,
+    Some(&artcraft_client.credentials),
+    request,
+  )
+    .await
+    .map_err(|err| ArtcraftRouterError::Provider(ProviderError::Storyteller(err)))?;
+
+  Ok(GenerateImageResponse::Artcraft(ArtcraftImageResponsePayload {
+    inference_job_token: response.inference_job_token,
+  }))
+}
+
+#[cfg(test)]
+mod tests {
+  use crate::api::common_aspect_ratio::CommonAspectRatio;
+  use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+  use crate::generate::generate_image::generate_image_request::GenerateImageRequest;
+  use crate::generate::generate_image::image_generation_plan::ImageGenerationPlan;
+  use crate::test_helpers::{base_flux_pro_1p1_ultra_image_request, get_artcraft_client};
+  use strum::IntoEnumIterator;
+
+  #[tokio::test]
+  #[ignore] // manually run — fires a real API request and incurs cost
+  async fn test_text_to_image_flux_pro_1p1_ultra() {
+    let client = get_artcraft_client();
+    let request = GenerateImageRequest {
+      aspect_ratio: Some(CommonAspectRatio::WideSixteenByNine),
+      image_batch_count: Some(1),
+      prompt: Some("a cat walking through a cyberpunk city at night"),
+      ..base_flux_pro_1p1_ultra_image_request()
+    };
+
+    let plan = request.build().unwrap();
+    let result = plan.generate_image(&client).await;
+
+    println!("Result: {:?}", result);
+    let response = result.expect("generate_image request failed");
+    let payload = response.get_artcraft_payload().expect("expected Artcraft payload");
+    println!("Job token: {:?}", payload.inference_job_token);
+
+    assert_eq!(1, 2); // NB: Intentional failure to inspect the response above.
+  }
+
+  #[tokio::test]
+  #[ignore] // manually run — fires a real API request and incurs cost
+  async fn test_text_to_image_flux_pro_1p1_ultra_batch_four() {
+    let client = get_artcraft_client();
+    let request = GenerateImageRequest {
+      aspect_ratio: Some(CommonAspectRatio::Square),
+      image_batch_count: Some(4),
+      prompt: Some("a dog surfing a wave, cinematic"),
+      ..base_flux_pro_1p1_ultra_image_request()
+    };
+
+    let plan = request.build().unwrap();
+    let result = plan.generate_image(&client).await;
+
+    println!("Result: {:?}", result);
+    let response = result.expect("generate_image request failed");
+    let payload = response.get_artcraft_payload().expect("expected Artcraft payload");
+    println!("Job token: {:?}", payload.inference_job_token);
+
+    assert_eq!(1, 2); // NB: Intentional failure to inspect the response above.
+  }
+
+  #[tokio::test]
+  #[ignore] // manually run — fires one real API request per aspect ratio variant (expensive)
+  async fn test_text_to_image_flux_pro_1p1_ultra_all_aspect_ratios() {
+    let client = get_artcraft_client();
+
+    for ar in CommonAspectRatio::iter() {
+      println!("--- text-to-image aspect ratio: {:?} ---", ar);
+      let request = GenerateImageRequest {
+        aspect_ratio: Some(ar),
+        image_batch_count: Some(1),
+        prompt: Some("a t-rex walking through an abandoned desert city at night"),
+        request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::PayMoreUpgrade,
+        ..base_flux_pro_1p1_ultra_image_request()
+      };
+      match request.build() {
+        Err(e) => println!("  plan error: {:?}", e),
+        Ok(plan) => match plan.generate_image(&client).await {
+          Ok(response) => {
+            let payload = response.get_artcraft_payload().expect("expected Artcraft payload");
+            println!("  job token: {:?}", payload.inference_job_token);
+          }
+          Err(e) => println!("  generate error: {:?}", e),
+        },
+      }
+    }
+
+    assert_eq!(1, 2); // NB: Intentional failure to inspect the responses above.
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/execute/artcraft/generate_image_artcraft_gpt_image_1p5.rs

@@ -0,0 +1,164 @@
+use crate::client::router_artcraft_client::RouterArtcraftClient;
+use crate::errors::artcraft_router_error::ArtcraftRouterError;
+use crate::errors::provider_error::ProviderError;
+use crate::generate::generate_image::generate_image_response::{
+  ArtcraftImageResponsePayload, GenerateImageResponse,
+};
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_gpt_image_1p5::PlanArtcraftGptImage1p5;
+use artcraft_api_defs::generate::image::multi_function::gpt_image_1p5_multi_function_image_gen::GptImage1p5MultiFunctionImageGenRequest;
+use artcraft_client::endpoints::generate::image::multi_function::gpt_image_1p5_multi_function_image_gen_image::gpt_image_1p5_multi_function_image_gen;
+
+pub async fn execute_artcraft_gpt_image_1p5(
+  plan: &PlanArtcraftGptImage1p5<'_>,
+  artcraft_client: &RouterArtcraftClient,
+) -> Result<GenerateImageResponse, ArtcraftRouterError> {
+  let request = GptImage1p5MultiFunctionImageGenRequest {
+    uuid_idempotency_token: plan.idempotency_token.clone(),
+    prompt: plan.prompt.map(|p| p.to_string()),
+    image_media_tokens: plan.image_inputs.map(|tokens| tokens.to_owned()),
+    mask_image_token: None,
+    num_images: Some(plan.num_images),
+    image_size: plan.image_size,
+    background: None,
+    quality: Some(plan.quality),
+    input_fidelity: None,
+    output_format: None,
+  };
+
+  let response = gpt_image_1p5_multi_function_image_gen(
+    &artcraft_client.api_host,
+    Some(&artcraft_client.credentials),
+    request,
+  )
+    .await
+    .map_err(|err| ArtcraftRouterError::Provider(ProviderError::Storyteller(err)))?;
+
+  Ok(GenerateImageResponse::Artcraft(ArtcraftImageResponsePayload {
+    inference_job_token: response.inference_job_token,
+  }))
+}
+
+#[cfg(test)]
+mod tests {
+  use crate::api::common_aspect_ratio::CommonAspectRatio;
+  use crate::api::image_list_ref::ImageListRef;
+  use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+  use crate::generate::generate_image::generate_image_request::GenerateImageRequest;
+  use crate::generate::generate_image::image_generation_plan::ImageGenerationPlan;
+  use crate::test_helpers::{base_gpt_image_1p5_image_request, get_artcraft_client};
+  use strum::IntoEnumIterator;
+  use tokens::tokens::media_files::MediaFileToken;
+
+  #[tokio::test]
+  #[ignore] // manually run — fires a real API request and incurs cost
+  async fn test_text_to_image_gpt_image_1p5() {
+    let client = get_artcraft_client();
+    let request = GenerateImageRequest {
+      aspect_ratio: Some(CommonAspectRatio::WideSixteenByNine),
+      image_batch_count: Some(1),
+      prompt: Some("a horse walking through a cyberpunk city at night"),
+      ..base_gpt_image_1p5_image_request()
+    };
+
+    let plan = request.build().unwrap();
+    let result = plan.generate_image(&client).await;
+
+    println!("Result: {:?}", result);
+    let response = result.expect("generate_image request failed");
+    let payload = response.get_artcraft_payload().expect("expected Artcraft payload");
+    println!("Job token: {:?}", payload.inference_job_token);
+
+    assert_eq!(1, 2); // NB: Intentional failure to inspect the response above.
+  }
+
+  #[tokio::test]
+  #[ignore] // manually run — fires a real API request and incurs cost
+  async fn test_edit_image_gpt_image_1p5() {
+    let client = get_artcraft_client();
+
+    let image_tokens = vec![
+      MediaFileToken::new_from_str("m_r45apt2swza6wp8j2z10237t92kkr8"),
+    ];
+
+    let request = GenerateImageRequest {
+      prompt: Some("Change the background to a desert with cacti"),
+      image_inputs: Some(ImageListRef::MediaFileTokens(&image_tokens)),
+      aspect_ratio: Some(CommonAspectRatio::Auto),
+      image_batch_count: Some(1),
+      ..base_gpt_image_1p5_image_request()
+    };
+
+    let plan = request.build().unwrap();
+    let result = plan.generate_image(&client).await;
+
+    println!("Result: {:?}", result);
+    let response = result.expect("generate_image request failed");
+    let payload = response.get_artcraft_payload().expect("expected Artcraft payload");
+    println!("Job token: {:?}", payload.inference_job_token);
+
+    assert_eq!(1, 2); // NB: Intentional failure to inspect the response above.
+  }
+
+  #[tokio::test]
+  #[ignore] // manually run — fires one real API request per aspect ratio variant (expensive)
+  async fn test_text_to_image_gpt_image_1p5_all_aspect_ratios() {
+    let client = get_artcraft_client();
+
+    for ar in CommonAspectRatio::iter() {
+      println!("--- text-to-image aspect ratio: {:?} ---", ar);
+      let request = GenerateImageRequest {
+        aspect_ratio: Some(ar),
+        image_batch_count: Some(1),
+        prompt: Some("a bear walking through a abandoned desert city at night"),
+        request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::PayMoreUpgrade,
+        ..base_gpt_image_1p5_image_request()
+      };
+      match request.build() {
+        Err(e) => println!("  plan error: {:?}", e),
+        Ok(plan) => match plan.generate_image(&client).await {
+          Ok(response) => {
+            let payload = response.get_artcraft_payload().expect("expected Artcraft payload");
+            println!("  job token: {:?}", payload.inference_job_token);
+          }
+          Err(e) => println!("  generate error: {:?}", e),
+        },
+      }
+    }
+
+    assert_eq!(1, 2); // NB: Intentional failure to inspect the responses above.
+  }
+
+  #[tokio::test]
+  #[ignore] // manually run — fires one real API request per aspect ratio variant (expensive)
+  async fn test_edit_image_gpt_image_1p5_all_aspect_ratios() {
+    let client = get_artcraft_client();
+
+    let image_tokens = vec![
+      MediaFileToken::new_from_str("m_r45apt2swza6wp8j2z10237t92kkr8"),
+    ];
+
+    for ar in CommonAspectRatio::iter() {
+      println!("--- image-edit aspect ratio: {:?} ---", ar);
+      let request = GenerateImageRequest {
+        prompt: Some("Change the background to an alien world"),
+        image_inputs: Some(ImageListRef::MediaFileTokens(&image_tokens)),
+        aspect_ratio: Some(ar),
+        image_batch_count: Some(1),
+        request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::PayMoreUpgrade,
+        ..base_gpt_image_1p5_image_request()
+      };
+      match request.build() {
+        Err(e) => println!("  plan error: {:?}", e),
+        Ok(plan) => match plan.generate_image(&client).await {
+          Ok(response) => {
+            let payload = response.get_artcraft_payload().expect("expected Artcraft payload");
+            println!("  job token: {:?}", payload.inference_job_token);
+          }
+          Err(e) => println!("  generate error: {:?}", e),
+        },
+      }
+    }
+
+    assert_eq!(1, 2); // NB: Intentional failure to inspect the responses above.
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/execute/artcraft/generate_image_artcraft_nano_banana.rs

@@ -0,0 +1,159 @@
+use crate::client::router_artcraft_client::RouterArtcraftClient;
+use crate::errors::artcraft_router_error::ArtcraftRouterError;
+use crate::errors::provider_error::ProviderError;
+use crate::generate::generate_image::generate_image_response::{
+  ArtcraftImageResponsePayload, GenerateImageResponse,
+};
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_nano_banana::PlanArtcraftNanaBanana;
+use artcraft_api_defs::generate::image::multi_function::nano_banana_multi_function_image_gen::NanoBananaMultiFunctionImageGenRequest;
+use artcraft_client::endpoints::generate::image::multi_function::nano_banana_multi_function_image_gen_image::nano_banana_multi_function_image_gen;
+
+pub async fn execute_artcraft_nano_banana(
+  plan: &PlanArtcraftNanaBanana<'_>,
+  artcraft_client: &RouterArtcraftClient,
+) -> Result<GenerateImageResponse, ArtcraftRouterError> {
+  let request = NanoBananaMultiFunctionImageGenRequest {
+    uuid_idempotency_token: plan.idempotency_token.clone(),
+    prompt: plan.prompt.map(|p| p.to_string()),
+    image_media_tokens: plan.image_inputs.map(|tokens| tokens.to_owned()),
+    num_images: Some(plan.num_images),
+    aspect_ratio: plan.aspect_ratio,
+  };
+
+  let response = nano_banana_multi_function_image_gen(
+    &artcraft_client.api_host,
+    Some(&artcraft_client.credentials),
+    request,
+  )
+    .await
+    .map_err(|err| ArtcraftRouterError::Provider(ProviderError::Storyteller(err)))?;
+
+  Ok(GenerateImageResponse::Artcraft(ArtcraftImageResponsePayload {
+    inference_job_token: response.inference_job_token,
+  }))
+}
+
+#[cfg(test)]
+mod tests {
+  use crate::api::common_aspect_ratio::CommonAspectRatio;
+  use crate::api::image_list_ref::ImageListRef;
+  use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+  use crate::generate::generate_image::generate_image_request::GenerateImageRequest;
+  use crate::generate::generate_image::image_generation_plan::ImageGenerationPlan;
+  use crate::test_helpers::{base_nano_banana_image_request, get_artcraft_client};
+  use strum::IntoEnumIterator;
+  use tokens::tokens::media_files::MediaFileToken;
+
+  #[tokio::test]
+  #[ignore] // manually run — fires a real API request and incurs cost
+  async fn test_text_to_image_nano_banana() {
+    let client = get_artcraft_client();
+    let request = GenerateImageRequest {
+      aspect_ratio: Some(CommonAspectRatio::WideSixteenByNine),
+      image_batch_count: Some(1),
+      prompt: Some("a cat walking through a cyberpunk city at night"),
+      ..base_nano_banana_image_request()
+    };
+
+    let plan = request.build().unwrap();
+    let result = plan.generate_image(&client).await;
+
+    println!("Result: {:?}", result);
+    let response = result.expect("generate_image request failed");
+    let payload = response.get_artcraft_payload().expect("expected Artcraft payload");
+    println!("Job token: {:?}", payload.inference_job_token);
+
+    assert_eq!(1, 2); // NB: Intentional failure to inspect the response above.
+  }
+
+  #[tokio::test]
+  #[ignore] // manually run — fires a real API request and incurs cost
+  async fn test_edit_image_nano_banana() {
+    let client = get_artcraft_client();
+
+    let image_tokens = vec![
+      MediaFileToken::new_from_str("m_r45apt2swza6wp8j2z10237t92kkr8"),
+    ];
+
+    let request = GenerateImageRequest {
+      prompt: Some("Change the background to a sunny beach"),
+      image_inputs: Some(ImageListRef::MediaFileTokens(&image_tokens)),
+      aspect_ratio: Some(CommonAspectRatio::Auto),
+      image_batch_count: Some(1),
+      ..base_nano_banana_image_request()
+    };
+
+    let plan = request.build().unwrap();
+    let result = plan.generate_image(&client).await;
+
+    println!("Result: {:?}", result);
+    let response = result.expect("generate_image request failed");
+    let payload = response.get_artcraft_payload().expect("expected Artcraft payload");
+    println!("Job token: {:?}", payload.inference_job_token);
+
+    assert_eq!(1, 2); // NB: Intentional failure to inspect the response above.
+  }
+
+  #[tokio::test]
+  #[ignore] // manually run — fires one real API request per aspect ratio variant (expensive)
+  async fn test_text_to_image_nano_banana_all_aspect_ratios() {
+    let client = get_artcraft_client();
+
+    for ar in CommonAspectRatio::iter() {
+      println!("--- text-to-image aspect ratio: {:?} ---", ar);
+      let request = GenerateImageRequest {
+        aspect_ratio: Some(ar),
+        image_batch_count: Some(1),
+        prompt: Some("a shiba walking through a cyberpunk city at night"),
+        request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::PayMoreUpgrade,
+        ..base_nano_banana_image_request()
+      };
+      match request.build() {
+        Err(e) => println!("  plan error: {:?}", e),
+        Ok(plan) => match plan.generate_image(&client).await {
+          Ok(response) => {
+            let payload = response.get_artcraft_payload().expect("expected Artcraft payload");
+            println!("  job token: {:?}", payload.inference_job_token);
+          }
+          Err(e) => println!("  generate error: {:?}", e),
+        },
+      }
+    }
+
+    assert_eq!(1, 2); // NB: Intentional failure to inspect the responses above.
+  }
+
+  #[tokio::test]
+  #[ignore] // manually run — fires one real API request per aspect ratio variant (expensive)
+  async fn test_edit_image_nano_banana_all_aspect_ratios() {
+    let client = get_artcraft_client();
+
+    let image_tokens = vec![
+      MediaFileToken::new_from_str("m_r45apt2swza6wp8j2z10237t92kkr8"),
+    ];
+
+    for ar in CommonAspectRatio::iter() {
+      println!("--- image-edit aspect ratio: {:?} ---", ar);
+      let request = GenerateImageRequest {
+        prompt: Some("Change the background to a sunny beach"),
+        image_inputs: Some(ImageListRef::MediaFileTokens(&image_tokens)),
+        aspect_ratio: Some(ar),
+        image_batch_count: Some(1),
+        request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::PayMoreUpgrade,
+        ..base_nano_banana_image_request()
+      };
+      match request.build() {
+        Err(e) => println!("  plan error: {:?}", e),
+        Ok(plan) => match plan.generate_image(&client).await {
+          Ok(response) => {
+            let payload = response.get_artcraft_payload().expect("expected Artcraft payload");
+            println!("  job token: {:?}", payload.inference_job_token);
+          }
+          Err(e) => println!("  generate error: {:?}", e),
+        },
+      }
+    }
+
+    assert_eq!(1, 2); // NB: Intentional failure to inspect the responses above.
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/execute/artcraft/generate_image_artcraft_nano_banana_2.rs

@@ -0,0 +1,67 @@
+use crate::client::router_artcraft_client::RouterArtcraftClient;
+use crate::errors::artcraft_router_error::ArtcraftRouterError;
+use crate::errors::provider_error::ProviderError;
+use crate::generate::generate_image::generate_image_response::{
+  ArtcraftImageResponsePayload, GenerateImageResponse,
+};
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_nano_banana_2::PlanArtcraftNanaBanana2;
+use artcraft_api_defs::generate::image::multi_function::nano_banana_2_multi_function_image_gen::NanaBanana2MultiFunctionImageGenRequest;
+use artcraft_client::endpoints::generate::image::multi_function::nano_banana_2_multi_function_image_gen_image::nano_banana_2_multi_function_image_gen;
+
+pub async fn execute_artcraft_nano_banana_2(
+  plan: &PlanArtcraftNanaBanana2<'_>,
+  artcraft_client: &RouterArtcraftClient,
+) -> Result<GenerateImageResponse, ArtcraftRouterError> {
+  let request = NanaBanana2MultiFunctionImageGenRequest {
+    uuid_idempotency_token: plan.idempotency_token.clone(),
+    prompt: plan.prompt.map(|p| p.to_string()),
+    image_media_tokens: plan.image_inputs.map(|tokens| tokens.to_owned()),
+    num_images: Some(plan.num_images),
+    resolution: plan.resolution,
+    aspect_ratio: plan.aspect_ratio,
+  };
+
+  let response = nano_banana_2_multi_function_image_gen(
+    &artcraft_client.api_host,
+    Some(&artcraft_client.credentials),
+    request,
+  )
+    .await
+    .map_err(|err| ArtcraftRouterError::Provider(ProviderError::Storyteller(err)))?;
+
+  Ok(GenerateImageResponse::Artcraft(ArtcraftImageResponsePayload {
+    inference_job_token: response.inference_job_token,
+  }))
+}
+
+#[cfg(test)]
+mod tests {
+  use crate::api::common_aspect_ratio::CommonAspectRatio;
+  use crate::api::common_resolution::CommonResolution;
+  use crate::generate::generate_image::generate_image_request::GenerateImageRequest;
+  use crate::generate::generate_image::image_generation_plan::ImageGenerationPlan;
+  use crate::test_helpers::{base_nano_banana_2_image_request, get_artcraft_client};
+
+  #[tokio::test]
+  #[ignore] // manually run — fires a real API request and incurs cost
+  async fn test_text_to_image_nano_banana_2() {
+    let client = get_artcraft_client();
+    let request = GenerateImageRequest {
+      aspect_ratio: Some(CommonAspectRatio::WideSixteenByNine),
+      resolution: Some(CommonResolution::OneK),
+      image_batch_count: Some(1),
+      prompt: Some("a cat walking through a cyberpunk city at night"),
+      ..base_nano_banana_2_image_request()
+    };
+
+    let plan = request.build().unwrap();
+    let result = plan.generate_image(&client).await;
+
+    println!("Result: {:?}", result);
+    let response = result.expect("generate_image request failed");
+    let payload = response.get_artcraft_payload().expect("expected Artcraft payload");
+    println!("Job token: {:?}", payload.inference_job_token);
+
+    assert_eq!(1, 2); // NB: Intentional failure to inspect the response above.
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/execute/artcraft/generate_image_artcraft_seedream_4.rs

@@ -0,0 +1,160 @@
+use crate::client::router_artcraft_client::RouterArtcraftClient;
+use crate::errors::artcraft_router_error::ArtcraftRouterError;
+use crate::errors::provider_error::ProviderError;
+use crate::generate::generate_image::generate_image_response::{
+  ArtcraftImageResponsePayload, GenerateImageResponse,
+};
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_seedream_4::PlanArtcraftSeedream4;
+use artcraft_api_defs::generate::image::multi_function::bytedance_seedream_v4_multi_function_image_gen::BytedanceSeedreamV4MultiFunctionImageGenRequest;
+use artcraft_client::endpoints::generate::image::multi_function::bytedance_seedream_v4_multi_function_image_gen_image::bytedance_seedream_v4_multi_function_image_gen;
+
+pub async fn execute_artcraft_seedream_4(
+  plan: &PlanArtcraftSeedream4<'_>,
+  artcraft_client: &RouterArtcraftClient,
+) -> Result<GenerateImageResponse, ArtcraftRouterError> {
+  let request = BytedanceSeedreamV4MultiFunctionImageGenRequest {
+    uuid_idempotency_token: plan.idempotency_token.clone(),
+    prompt: plan.prompt.map(|p| p.to_string()),
+    image_media_tokens: plan.image_inputs.map(|tokens| tokens.to_owned()),
+    num_images: Some(plan.num_images),
+    image_size: plan.image_size,
+    max_images: None,
+  };
+
+  let response = bytedance_seedream_v4_multi_function_image_gen(
+    &artcraft_client.api_host,
+    Some(&artcraft_client.credentials),
+    request,
+  )
+    .await
+    .map_err(|err| ArtcraftRouterError::Provider(ProviderError::Storyteller(err)))?;
+
+  Ok(GenerateImageResponse::Artcraft(ArtcraftImageResponsePayload {
+    inference_job_token: response.inference_job_token,
+  }))
+}
+
+#[cfg(test)]
+mod tests {
+  use crate::api::common_aspect_ratio::CommonAspectRatio;
+  use crate::api::image_list_ref::ImageListRef;
+  use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+  use crate::generate::generate_image::generate_image_request::GenerateImageRequest;
+  use crate::generate::generate_image::image_generation_plan::ImageGenerationPlan;
+  use crate::test_helpers::{base_seedream_4_image_request, get_artcraft_client};
+  use strum::IntoEnumIterator;
+  use tokens::tokens::media_files::MediaFileToken;
+
+  #[tokio::test]
+  #[ignore] // manually run — fires a real API request and incurs cost
+  async fn test_text_to_image_seedream_4() {
+    let client = get_artcraft_client();
+    let request = GenerateImageRequest {
+      aspect_ratio: Some(CommonAspectRatio::WideSixteenByNine),
+      image_batch_count: Some(1),
+      prompt: Some("a cat walking through a cyberpunk city at night"),
+      ..base_seedream_4_image_request()
+    };
+
+    let plan = request.build().unwrap();
+    let result = plan.generate_image(&client).await;
+
+    println!("Result: {:?}", result);
+    let response = result.expect("generate_image request failed");
+    let payload = response.get_artcraft_payload().expect("expected Artcraft payload");
+    println!("Job token: {:?}", payload.inference_job_token);
+
+    assert_eq!(1, 2); // NB: Intentional failure to inspect the response above.
+  }
+
+  #[tokio::test]
+  #[ignore] // manually run — fires a real API request and incurs cost
+  async fn test_edit_image_seedream_4() {
+    let client = get_artcraft_client();
+
+    let image_tokens = vec![
+      MediaFileToken::new_from_str("m_r45apt2swza6wp8j2z10237t92kkr8"),
+    ];
+
+    let request = GenerateImageRequest {
+      prompt: Some("Change the background to a sunny beach"),
+      image_inputs: Some(ImageListRef::MediaFileTokens(&image_tokens)),
+      aspect_ratio: Some(CommonAspectRatio::Auto),
+      image_batch_count: Some(1),
+      ..base_seedream_4_image_request()
+    };
+
+    let plan = request.build().unwrap();
+    let result = plan.generate_image(&client).await;
+
+    println!("Result: {:?}", result);
+    let response = result.expect("generate_image request failed");
+    let payload = response.get_artcraft_payload().expect("expected Artcraft payload");
+    println!("Job token: {:?}", payload.inference_job_token);
+
+    assert_eq!(1, 2); // NB: Intentional failure to inspect the response above.
+  }
+
+  #[tokio::test]
+  #[ignore] // manually run — fires one real API request per aspect ratio variant (expensive)
+  async fn test_text_to_image_seedream_4_all_aspect_ratios() {
+    let client = get_artcraft_client();
+
+    for ar in CommonAspectRatio::iter() {
+      println!("--- text-to-image aspect ratio: {:?} ---", ar);
+      let request = GenerateImageRequest {
+        aspect_ratio: Some(ar),
+        image_batch_count: Some(1),
+        prompt: Some("a shiba walking through a cyberpunk city at night"),
+        request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::PayMoreUpgrade,
+        ..base_seedream_4_image_request()
+      };
+      match request.build() {
+        Err(e) => println!("  plan error: {:?}", e),
+        Ok(plan) => match plan.generate_image(&client).await {
+          Ok(response) => {
+            let payload = response.get_artcraft_payload().expect("expected Artcraft payload");
+            println!("  job token: {:?}", payload.inference_job_token);
+          }
+          Err(e) => println!("  generate error: {:?}", e),
+        },
+      }
+    }
+
+    assert_eq!(1, 2); // NB: Intentional failure to inspect the responses above.
+  }
+
+  #[tokio::test]
+  #[ignore] // manually run — fires one real API request per aspect ratio variant (expensive)
+  async fn test_edit_image_seedream_4_all_aspect_ratios() {
+    let client = get_artcraft_client();
+
+    let image_tokens = vec![
+      MediaFileToken::new_from_str("m_r45apt2swza6wp8j2z10237t92kkr8"),
+    ];
+
+    for ar in CommonAspectRatio::iter() {
+      println!("--- image-edit aspect ratio: {:?} ---", ar);
+      let request = GenerateImageRequest {
+        prompt: Some("Change the background to a sunny beach"),
+        image_inputs: Some(ImageListRef::MediaFileTokens(&image_tokens)),
+        aspect_ratio: Some(ar),
+        image_batch_count: Some(1),
+        request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::PayMoreUpgrade,
+        ..base_seedream_4_image_request()
+      };
+      match request.build() {
+        Err(e) => println!("  plan error: {:?}", e),
+        Ok(plan) => match plan.generate_image(&client).await {
+          Ok(response) => {
+            let payload = response.get_artcraft_payload().expect("expected Artcraft payload");
+            println!("  job token: {:?}", payload.inference_job_token);
+          }
+          Err(e) => println!("  generate error: {:?}", e),
+        },
+      }
+    }
+
+    assert_eq!(1, 2); // NB: Intentional failure to inspect the responses above.
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/execute/artcraft/generate_image_artcraft_seedream_4p5.rs

@@ -0,0 +1,160 @@
+use crate::client::router_artcraft_client::RouterArtcraftClient;
+use crate::errors::artcraft_router_error::ArtcraftRouterError;
+use crate::errors::provider_error::ProviderError;
+use crate::generate::generate_image::generate_image_response::{
+  ArtcraftImageResponsePayload, GenerateImageResponse,
+};
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_seedream_4p5::PlanArtcraftSeedream4p5;
+use artcraft_api_defs::generate::image::multi_function::bytedance_seedream_v4p5_multi_function_image_gen::BytedanceSeedreamV4p5MultiFunctionImageGenRequest;
+use artcraft_client::endpoints::generate::image::multi_function::bytedance_seedream_v4p5_multi_function_image_gen_image::bytedance_seedream_v4p5_multi_function_image_gen;
+
+pub async fn execute_artcraft_seedream_4p5(
+  plan: &PlanArtcraftSeedream4p5<'_>,
+  artcraft_client: &RouterArtcraftClient,
+) -> Result<GenerateImageResponse, ArtcraftRouterError> {
+  let request = BytedanceSeedreamV4p5MultiFunctionImageGenRequest {
+    uuid_idempotency_token: plan.idempotency_token.clone(),
+    prompt: plan.prompt.map(|p| p.to_string()),
+    image_media_tokens: plan.image_inputs.map(|tokens| tokens.to_owned()),
+    num_images: Some(plan.num_images),
+    image_size: plan.image_size,
+    max_images: None,
+  };
+
+  let response = bytedance_seedream_v4p5_multi_function_image_gen(
+    &artcraft_client.api_host,
+    Some(&artcraft_client.credentials),
+    request,
+  )
+    .await
+    .map_err(|err| ArtcraftRouterError::Provider(ProviderError::Storyteller(err)))?;
+
+  Ok(GenerateImageResponse::Artcraft(ArtcraftImageResponsePayload {
+    inference_job_token: response.inference_job_token,
+  }))
+}
+
+#[cfg(test)]
+mod tests {
+  use crate::api::common_aspect_ratio::CommonAspectRatio;
+  use crate::api::image_list_ref::ImageListRef;
+  use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+  use crate::generate::generate_image::generate_image_request::GenerateImageRequest;
+  use crate::generate::generate_image::image_generation_plan::ImageGenerationPlan;
+  use crate::test_helpers::{base_seedream_4p5_image_request, get_artcraft_client};
+  use strum::IntoEnumIterator;
+  use tokens::tokens::media_files::MediaFileToken;
+
+  #[tokio::test]
+  #[ignore] // manually run — fires a real API request and incurs cost
+  async fn test_text_to_image_seedream_4p5() {
+    let client = get_artcraft_client();
+    let request = GenerateImageRequest {
+      aspect_ratio: Some(CommonAspectRatio::WideSixteenByNine),
+      image_batch_count: Some(1),
+      prompt: Some("a corgi walking through a cyberpunk city at night"),
+      ..base_seedream_4p5_image_request()
+    };
+
+    let plan = request.build().unwrap();
+    let result = plan.generate_image(&client).await;
+
+    println!("Result: {:?}", result);
+    let response = result.expect("generate_image request failed");
+    let payload = response.get_artcraft_payload().expect("expected Artcraft payload");
+    println!("Job token: {:?}", payload.inference_job_token);
+
+    assert_eq!(1, 2); // NB: Intentional failure to inspect the response above.
+  }
+
+  #[tokio::test]
+  #[ignore] // manually run — fires a real API request and incurs cost
+  async fn test_edit_image_seedream_4p5() {
+    let client = get_artcraft_client();
+
+    let image_tokens = vec![
+      MediaFileToken::new_from_str("m_r45apt2swza6wp8j2z10237t92kkr8"),
+    ];
+
+    let request = GenerateImageRequest {
+      prompt: Some("Change the background to a spooky haunted house"),
+      image_inputs: Some(ImageListRef::MediaFileTokens(&image_tokens)),
+      aspect_ratio: Some(CommonAspectRatio::Auto2k),
+      image_batch_count: Some(1),
+      ..base_seedream_4p5_image_request()
+    };
+
+    let plan = request.build().unwrap();
+    let result = plan.generate_image(&client).await;
+
+    println!("Result: {:?}", result);
+    let response = result.expect("generate_image request failed");
+    let payload = response.get_artcraft_payload().expect("expected Artcraft payload");
+    println!("Job token: {:?}", payload.inference_job_token);
+
+    assert_eq!(1, 2); // NB: Intentional failure to inspect the response above.
+  }
+
+  #[tokio::test]
+  #[ignore] // manually run — fires one real API request per aspect ratio variant (expensive)
+  async fn test_text_to_image_seedream_4p5_all_aspect_ratios() {
+    let client = get_artcraft_client();
+
+    for ar in CommonAspectRatio::iter() {
+      println!("--- text-to-image aspect ratio: {:?} ---", ar);
+      let request = GenerateImageRequest {
+        aspect_ratio: Some(ar),
+        image_batch_count: Some(1),
+        prompt: Some("a corgi walking through a cyberpunk city at night"),
+        request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::PayMoreUpgrade,
+        ..base_seedream_4p5_image_request()
+      };
+      match request.build() {
+        Err(e) => println!("  plan error: {:?}", e),
+        Ok(plan) => match plan.generate_image(&client).await {
+          Ok(response) => {
+            let payload = response.get_artcraft_payload().expect("expected Artcraft payload");
+            println!("  job token: {:?}", payload.inference_job_token);
+          }
+          Err(e) => println!("  generate error: {:?}", e),
+        },
+      }
+    }
+
+    assert_eq!(1, 2); // NB: Intentional failure to inspect the responses above.
+  }
+
+  #[tokio::test]
+  #[ignore] // manually run — fires one real API request per aspect ratio variant (expensive)
+  async fn test_edit_image_seedream_4p5_all_aspect_ratios() {
+    let client = get_artcraft_client();
+
+    let image_tokens = vec![
+      MediaFileToken::new_from_str("m_r45apt2swza6wp8j2z10237t92kkr8"),
+    ];
+
+    for ar in CommonAspectRatio::iter() {
+      println!("--- image-edit aspect ratio: {:?} ---", ar);
+      let request = GenerateImageRequest {
+        prompt: Some("Change the background to a spooky haunted house"),
+        image_inputs: Some(ImageListRef::MediaFileTokens(&image_tokens)),
+        aspect_ratio: Some(ar),
+        image_batch_count: Some(1),
+        request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::PayMoreUpgrade,
+        ..base_seedream_4p5_image_request()
+      };
+      match request.build() {
+        Err(e) => println!("  plan error: {:?}", e),
+        Ok(plan) => match plan.generate_image(&client).await {
+          Ok(response) => {
+            let payload = response.get_artcraft_payload().expect("expected Artcraft payload");
+            println!("  job token: {:?}", payload.inference_job_token);
+          }
+          Err(e) => println!("  generate error: {:?}", e),
+        },
+      }
+    }
+
+    assert_eq!(1, 2); // NB: Intentional failure to inspect the responses above.
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/execute/artcraft/generate_image_artcraft_seedream_5_lite.rs

@@ -0,0 +1,65 @@
+use crate::client::router_artcraft_client::RouterArtcraftClient;
+use crate::errors::artcraft_router_error::ArtcraftRouterError;
+use crate::errors::provider_error::ProviderError;
+use crate::generate::generate_image::generate_image_response::{
+  ArtcraftImageResponsePayload, GenerateImageResponse,
+};
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_seedream_5_lite::PlanArtcraftSeedream5Lite;
+use artcraft_api_defs::generate::image::multi_function::bytedance_seedream_5_lite_multi_function_image_gen::BytedanceSeedream5LiteMultiFunctionImageGenRequest;
+use artcraft_client::endpoints::generate::image::multi_function::bytedance_seedream_5_lite_multi_function_image_gen_image::bytedance_seedream_5_lite_multi_function_image_gen;
+
+pub async fn execute_artcraft_seedream_5_lite(
+  plan: &PlanArtcraftSeedream5Lite<'_>,
+  artcraft_client: &RouterArtcraftClient,
+) -> Result<GenerateImageResponse, ArtcraftRouterError> {
+  let request = BytedanceSeedream5LiteMultiFunctionImageGenRequest {
+    uuid_idempotency_token: plan.idempotency_token.clone(),
+    prompt: plan.prompt.map(|p| p.to_string()),
+    image_media_tokens: plan.image_inputs.map(|tokens| tokens.to_owned()),
+    num_images: Some(plan.num_images),
+    image_size: plan.image_size,
+    max_images: None,
+  };
+
+  let response = bytedance_seedream_5_lite_multi_function_image_gen(
+    &artcraft_client.api_host,
+    Some(&artcraft_client.credentials),
+    request,
+  )
+    .await
+    .map_err(|err| ArtcraftRouterError::Provider(ProviderError::Storyteller(err)))?;
+
+  Ok(GenerateImageResponse::Artcraft(ArtcraftImageResponsePayload {
+    inference_job_token: response.inference_job_token,
+  }))
+}
+
+#[cfg(test)]
+mod tests {
+  use crate::api::common_aspect_ratio::CommonAspectRatio;
+  use crate::generate::generate_image::generate_image_request::GenerateImageRequest;
+  use crate::generate::generate_image::image_generation_plan::ImageGenerationPlan;
+  use crate::test_helpers::{base_seedream_5_lite_image_request, get_artcraft_client};
+
+  #[tokio::test]
+  #[ignore] // manually run — fires a real API request and incurs cost
+  async fn test_text_to_image_seedream_5_lite() {
+    let client = get_artcraft_client();
+    let request = GenerateImageRequest {
+      aspect_ratio: Some(CommonAspectRatio::WideSixteenByNine),
+      image_batch_count: Some(1),
+      prompt: Some("a corgi walking through a cyberpunk city at night"),
+      ..base_seedream_5_lite_image_request()
+    };
+
+    let plan = request.build().unwrap();
+    let result = plan.generate_image(&client).await;
+
+    println!("Result: {:?}", result);
+    let response = result.expect("generate_image request failed");
+    let payload = response.get_artcraft_payload().expect("expected Artcraft payload");
+    println!("Job token: {:?}", payload.inference_job_token);
+
+    assert_eq!(1, 2); // NB: Intentional failure to inspect the response above.
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/execute/artcraft/mod.rs

@@ -1 +1,11 @@
+pub mod generate_image_artcraft_flux_1_dev;
+pub mod generate_image_artcraft_flux_1_schnell;
+pub mod generate_image_artcraft_flux_pro_1p1;
+pub mod generate_image_artcraft_flux_pro_1p1_ultra;
+pub mod generate_image_artcraft_gpt_image_1p5;
+pub mod generate_image_artcraft_nano_banana;
+pub mod generate_image_artcraft_nano_banana_2;
 pub mod generate_image_artcraft_nano_banana_pro;
+pub mod generate_image_artcraft_seedream_4;
+pub mod generate_image_artcraft_seedream_4p5;
+pub mod generate_image_artcraft_seedream_5_lite;

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/generate_image_request.rs

@@ -3,10 +3,22 @@ use crate::api::common_image_model::CommonImageModel;
 use crate::api::common_resolution::CommonResolution;
 use crate::api::image_list_ref::ImageListRef;
 use crate::api::provider::Provider;
+use crate::client::generation_mode_mismatch_strategy::GenerationModeMismatchStrategy;
 use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
 use crate::errors::artcraft_router_error::ArtcraftRouterError;
+use crate::errors::client_error::ClientError;
 use crate::generate::generate_image::image_generation_plan::ImageGenerationPlan;
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_flux_1_dev::plan_generate_image_artcraft_flux_1_dev;
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_flux_1_schnell::plan_generate_image_artcraft_flux_1_schnell;
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_flux_pro_1p1::plan_generate_image_artcraft_flux_pro_1p1;
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_flux_pro_1p1_ultra::plan_generate_image_artcraft_flux_pro_1p1_ultra;
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_gpt_image_1p5::plan_generate_image_artcraft_gpt_image_1p5;
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_nano_banana::plan_generate_image_artcraft_nano_banana;
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_nano_banana_2::plan_generate_image_artcraft_nano_banana_2;
 use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_nano_banana_pro::plan_generate_image_artcraft_nano_banana_pro;
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_seedream_4::plan_generate_image_artcraft_seedream_4;
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_seedream_4p5::plan_generate_image_artcraft_seedream_4p5;
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_seedream_5_lite::plan_generate_image_artcraft_seedream_5_lite;
 use crate::generate::generate_image::plan::fal::plan_generate_image_fal_nano_banana_pro::plan_generate_image_fal_nano_banana_pro;
 
 pub struct GenerateImageRequest<'a> {
@@ -36,6 +48,11 @@ pub struct GenerateImageRequest<'a> {
   /// If the request is a mismatch with the (model/provider), how to mitigate it.
   pub request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy,
 
+  /// Controls behavior when `image_inputs` are supplied to a text-to-image-only model.
+  /// `None` is equivalent to `GenerateAnyway` — image inputs are silently ignored.
+  /// Set `AbortGeneration` to return an error instead.
+  pub generation_mode_mismatch_strategy: Option<GenerationModeMismatchStrategy>,
+
   /// Some providers support idempotency.
   /// If not supplied, we'll generate one for the required providers.
   pub idempotency_token: Option<&'a str>,
@@ -46,14 +63,59 @@ impl<'a> GenerateImageRequest<'a> {
   pub fn build(&self) -> Result<ImageGenerationPlan<'_>, ArtcraftRouterError> {
     match self.provider {
       Provider::Artcraft => match self.model {
+        CommonImageModel::Flux1Dev => {
+          plan_generate_image_artcraft_flux_1_dev(self).map(ImageGenerationPlan::ArtcraftFlux1Dev)
+        }
+        CommonImageModel::Flux1Schnell => {
+          plan_generate_image_artcraft_flux_1_schnell(self).map(ImageGenerationPlan::ArtcraftFlux1Schnell)
+        }
+        CommonImageModel::FluxPro11 => {
+          plan_generate_image_artcraft_flux_pro_1p1(self).map(ImageGenerationPlan::ArtcraftFluxPro11)
+        }
+        CommonImageModel::FluxPro11Ultra => {
+          plan_generate_image_artcraft_flux_pro_1p1_ultra(self).map(ImageGenerationPlan::ArtcraftFluxPro11Ultra)
+        }
+        CommonImageModel::GptImage1p5 => {
+          plan_generate_image_artcraft_gpt_image_1p5(self).map(ImageGenerationPlan::ArtcraftGptImage1p5)
+        }
+        CommonImageModel::NanaBanana => {
+          plan_generate_image_artcraft_nano_banana(self).map(ImageGenerationPlan::ArtcraftNanaBanana)
+        }
+        CommonImageModel::NanaBanana2 => {
+          plan_generate_image_artcraft_nano_banana_2(self).map(ImageGenerationPlan::ArtcraftNanaBanana2)
+        }
         CommonImageModel::NanaBananaPro => {
           plan_generate_image_artcraft_nano_banana_pro(self).map(ImageGenerationPlan::ArtcraftNanaBananaPro)
         }
+        CommonImageModel::Seedream4 => {
+          plan_generate_image_artcraft_seedream_4(self).map(ImageGenerationPlan::ArtcraftSeedream4)
+        }
+        CommonImageModel::Seedream4p5 => {
+          plan_generate_image_artcraft_seedream_4p5(self).map(ImageGenerationPlan::ArtcraftSeedream4p5)
+        }
+        CommonImageModel::Seedream5Lite => {
+          plan_generate_image_artcraft_seedream_5_lite(self).map(ImageGenerationPlan::ArtcraftSeedream5Lite)
+        }
       },
       Provider::Fal => match self.model {
         CommonImageModel::NanaBananaPro => {
           plan_generate_image_fal_nano_banana_pro(self).map(ImageGenerationPlan::FalNanaBananaPro)
         }
+        CommonImageModel::Flux1Dev
+        | CommonImageModel::Flux1Schnell
+        | CommonImageModel::FluxPro11
+        | CommonImageModel::FluxPro11Ultra
+        | CommonImageModel::GptImage1p5
+        | CommonImageModel::NanaBanana
+        | CommonImageModel::NanaBanana2
+        | CommonImageModel::Seedream4
+        | CommonImageModel::Seedream4p5
+        | CommonImageModel::Seedream5Lite => {
+          Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+            field: "provider",
+            value: format!("{:?} is only available on the Artcraft provider", self.model),
+          }))
+        }
       },
     }
   }

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/image_generation_plan.rs

@@ -1,17 +1,57 @@
 use crate::client::router_client::RouterClient;
 use crate::errors::artcraft_router_error::ArtcraftRouterError;
+use crate::generate::generate_image::cost::artcraft::estimate_image_cost_artcraft_flux_1_dev::estimate_image_cost_artcraft_flux_1_dev;
+use crate::generate::generate_image::cost::artcraft::estimate_image_cost_artcraft_flux_1_schnell::estimate_image_cost_artcraft_flux_1_schnell;
+use crate::generate::generate_image::cost::artcraft::estimate_image_cost_artcraft_flux_pro_1p1::estimate_image_cost_artcraft_flux_pro_1p1;
+use crate::generate::generate_image::cost::artcraft::estimate_image_cost_artcraft_flux_pro_1p1_ultra::estimate_image_cost_artcraft_flux_pro_1p1_ultra;
+use crate::generate::generate_image::cost::artcraft::estimate_image_cost_artcraft_gpt_image_1p5::estimate_image_cost_artcraft_gpt_image_1p5;
+use crate::generate::generate_image::cost::artcraft::estimate_image_cost_artcraft_nano_banana::estimate_image_cost_artcraft_nano_banana;
+use crate::generate::generate_image::cost::artcraft::estimate_image_cost_artcraft_nano_banana_2::estimate_image_cost_artcraft_nano_banana_2;
 use crate::generate::generate_image::cost::artcraft::estimate_image_cost_artcraft_nano_banana_pro::estimate_image_cost_artcraft_nano_banana_pro;
+use crate::generate::generate_image::cost::artcraft::estimate_image_cost_artcraft_seedream_4::estimate_image_cost_artcraft_seedream_4;
+use crate::generate::generate_image::cost::artcraft::estimate_image_cost_artcraft_seedream_4p5::estimate_image_cost_artcraft_seedream_4p5;
+use crate::generate::generate_image::cost::artcraft::estimate_image_cost_artcraft_seedream_5_lite::estimate_image_cost_artcraft_seedream_5_lite;
 use crate::generate::generate_image::cost::fal::estimate_image_cost_fal_nano_banana_pro::estimate_image_cost_fal_nano_banana_pro;
+use crate::generate::generate_image::execute::artcraft::generate_image_artcraft_flux_1_dev::execute_artcraft_flux_1_dev;
+use crate::generate::generate_image::execute::artcraft::generate_image_artcraft_flux_1_schnell::execute_artcraft_flux_1_schnell;
+use crate::generate::generate_image::execute::artcraft::generate_image_artcraft_flux_pro_1p1::execute_artcraft_flux_pro_1p1;
+use crate::generate::generate_image::execute::artcraft::generate_image_artcraft_flux_pro_1p1_ultra::execute_artcraft_flux_pro_1p1_ultra;
+use crate::generate::generate_image::execute::artcraft::generate_image_artcraft_gpt_image_1p5::execute_artcraft_gpt_image_1p5;
+use crate::generate::generate_image::execute::artcraft::generate_image_artcraft_nano_banana::execute_artcraft_nano_banana;
+use crate::generate::generate_image::execute::artcraft::generate_image_artcraft_nano_banana_2::execute_artcraft_nano_banana_2;
 use crate::generate::generate_image::execute::artcraft::generate_image_artcraft_nano_banana_pro::execute_artcraft_nano_banana_pro;
+use crate::generate::generate_image::execute::artcraft::generate_image_artcraft_seedream_4::execute_artcraft_seedream_4;
+use crate::generate::generate_image::execute::artcraft::generate_image_artcraft_seedream_4p5::execute_artcraft_seedream_4p5;
+use crate::generate::generate_image::execute::artcraft::generate_image_artcraft_seedream_5_lite::execute_artcraft_seedream_5_lite;
 use crate::generate::generate_image::execute::fal::generate_image_fal_nano_banana_pro::execute_fal_nano_banana_pro;
 use crate::generate::generate_image::generate_image_response::GenerateImageResponse;
 use crate::generate::generate_image::image_generation_cost_estimate::ImageGenerationCostEstimate;
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_flux_1_dev::PlanArtcraftFlux1Dev;
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_flux_1_schnell::PlanArtcraftFlux1Schnell;
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_flux_pro_1p1::PlanArtcraftFluxPro11;
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_flux_pro_1p1_ultra::PlanArtcraftFluxPro11Ultra;
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_gpt_image_1p5::PlanArtcraftGptImage1p5;
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_nano_banana::PlanArtcraftNanaBanana;
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_nano_banana_2::PlanArtcraftNanaBanana2;
 use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_nano_banana_pro::PlanArtcraftNanaBananaPro;
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_seedream_4::PlanArtcraftSeedream4;
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_seedream_4p5::PlanArtcraftSeedream4p5;
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_seedream_5_lite::PlanArtcraftSeedream5Lite;
 use crate::generate::generate_image::plan::fal::plan_generate_image_fal_nano_banana_pro::PlanFalNanaBananaPro;
 
 #[derive(Debug)]
 pub enum ImageGenerationPlan<'a> {
+  ArtcraftFlux1Dev(PlanArtcraftFlux1Dev<'a>),
+  ArtcraftFlux1Schnell(PlanArtcraftFlux1Schnell<'a>),
+  ArtcraftFluxPro11(PlanArtcraftFluxPro11<'a>),
+  ArtcraftFluxPro11Ultra(PlanArtcraftFluxPro11Ultra<'a>),
+  ArtcraftGptImage1p5(PlanArtcraftGptImage1p5<'a>),
+  ArtcraftNanaBanana(PlanArtcraftNanaBanana<'a>),
+  ArtcraftNanaBanana2(PlanArtcraftNanaBanana2<'a>),
   ArtcraftNanaBananaPro(PlanArtcraftNanaBananaPro<'a>),
+  ArtcraftSeedream4(PlanArtcraftSeedream4<'a>),
+  ArtcraftSeedream4p5(PlanArtcraftSeedream4p5<'a>),
+  ArtcraftSeedream5Lite(PlanArtcraftSeedream5Lite<'a>),
   FalNanaBananaPro(PlanFalNanaBananaPro<'a>),
 }
 
@@ -21,10 +61,50 @@ impl<'a> ImageGenerationPlan<'a> {
     client: &RouterClient,
   ) -> Result<GenerateImageResponse, ArtcraftRouterError> {
     match self {
+      ImageGenerationPlan::ArtcraftFlux1Dev(plan) => {
+        let artcraft_client = client.get_artcraft_client_ref()?;
+        execute_artcraft_flux_1_dev(plan, artcraft_client).await
+      }
+      ImageGenerationPlan::ArtcraftFlux1Schnell(plan) => {
+        let artcraft_client = client.get_artcraft_client_ref()?;
+        execute_artcraft_flux_1_schnell(plan, artcraft_client).await
+      }
+      ImageGenerationPlan::ArtcraftFluxPro11(plan) => {
+        let artcraft_client = client.get_artcraft_client_ref()?;
+        execute_artcraft_flux_pro_1p1(plan, artcraft_client).await
+      }
+      ImageGenerationPlan::ArtcraftFluxPro11Ultra(plan) => {
+        let artcraft_client = client.get_artcraft_client_ref()?;
+        execute_artcraft_flux_pro_1p1_ultra(plan, artcraft_client).await
+      }
+      ImageGenerationPlan::ArtcraftGptImage1p5(plan) => {
+        let artcraft_client = client.get_artcraft_client_ref()?;
+        execute_artcraft_gpt_image_1p5(plan, artcraft_client).await
+      }
+      ImageGenerationPlan::ArtcraftNanaBanana(plan) => {
+        let artcraft_client = client.get_artcraft_client_ref()?;
+        execute_artcraft_nano_banana(plan, artcraft_client).await
+      }
+      ImageGenerationPlan::ArtcraftNanaBanana2(plan) => {
+        let artcraft_client = client.get_artcraft_client_ref()?;
+        execute_artcraft_nano_banana_2(plan, artcraft_client).await
+      }
       ImageGenerationPlan::ArtcraftNanaBananaPro(plan) => {
         let artcraft_client = client.get_artcraft_client_ref()?;
         execute_artcraft_nano_banana_pro(plan, artcraft_client).await
       }
+      ImageGenerationPlan::ArtcraftSeedream4(plan) => {
+        let artcraft_client = client.get_artcraft_client_ref()?;
+        execute_artcraft_seedream_4(plan, artcraft_client).await
+      }
+      ImageGenerationPlan::ArtcraftSeedream4p5(plan) => {
+        let artcraft_client = client.get_artcraft_client_ref()?;
+        execute_artcraft_seedream_4p5(plan, artcraft_client).await
+      }
+      ImageGenerationPlan::ArtcraftSeedream5Lite(plan) => {
+        let artcraft_client = client.get_artcraft_client_ref()?;
+        execute_artcraft_seedream_5_lite(plan, artcraft_client).await
+      }
       ImageGenerationPlan::FalNanaBananaPro(plan) => {
         let fal_client = client.get_fal_client_ref()?;
         execute_fal_nano_banana_pro(plan, fal_client).await
@@ -34,9 +114,39 @@ impl<'a> ImageGenerationPlan<'a> {
 
   pub fn estimate_costs(&self) -> ImageGenerationCostEstimate {
     match self {
+      ImageGenerationPlan::ArtcraftFlux1Dev(plan) => {
+        estimate_image_cost_artcraft_flux_1_dev(plan)
+      }
+      ImageGenerationPlan::ArtcraftFlux1Schnell(plan) => {
+        estimate_image_cost_artcraft_flux_1_schnell(plan)
+      }
+      ImageGenerationPlan::ArtcraftFluxPro11(plan) => {
+        estimate_image_cost_artcraft_flux_pro_1p1(plan)
+      }
+      ImageGenerationPlan::ArtcraftFluxPro11Ultra(plan) => {
+        estimate_image_cost_artcraft_flux_pro_1p1_ultra(plan)
+      }
+      ImageGenerationPlan::ArtcraftGptImage1p5(plan) => {
+        estimate_image_cost_artcraft_gpt_image_1p5(plan)
+      }
+      ImageGenerationPlan::ArtcraftNanaBanana(plan) => {
+        estimate_image_cost_artcraft_nano_banana(plan)
+      }
+      ImageGenerationPlan::ArtcraftNanaBanana2(plan) => {
+        estimate_image_cost_artcraft_nano_banana_2(plan)
+      }
       ImageGenerationPlan::ArtcraftNanaBananaPro(plan) => {
         estimate_image_cost_artcraft_nano_banana_pro(plan)
       }
+      ImageGenerationPlan::ArtcraftSeedream4(plan) => {
+        estimate_image_cost_artcraft_seedream_4(plan)
+      }
+      ImageGenerationPlan::ArtcraftSeedream4p5(plan) => {
+        estimate_image_cost_artcraft_seedream_4p5(plan)
+      }
+      ImageGenerationPlan::ArtcraftSeedream5Lite(plan) => {
+        estimate_image_cost_artcraft_seedream_5_lite(plan)
+      }
       ImageGenerationPlan::FalNanaBananaPro(plan) => {
         estimate_image_cost_fal_nano_banana_pro(plan)
       }

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/plan/artcraft/mod.rs

@@ -1 +1,11 @@
+pub mod plan_generate_image_artcraft_flux_1_dev;
+pub mod plan_generate_image_artcraft_flux_1_schnell;
+pub mod plan_generate_image_artcraft_flux_pro_1p1;
+pub mod plan_generate_image_artcraft_flux_pro_1p1_ultra;
+pub mod plan_generate_image_artcraft_gpt_image_1p5;
+pub mod plan_generate_image_artcraft_nano_banana;
+pub mod plan_generate_image_artcraft_nano_banana_2;
 pub mod plan_generate_image_artcraft_nano_banana_pro;
+pub mod plan_generate_image_artcraft_seedream_4;
+pub mod plan_generate_image_artcraft_seedream_4p5;
+pub mod plan_generate_image_artcraft_seedream_5_lite;

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/plan/artcraft/plan_generate_image_artcraft_flux_1_dev.rs

@@ -0,0 +1,323 @@
+use crate::api::common_aspect_ratio::CommonAspectRatio;
+use crate::client::generation_mode_mismatch_strategy::GenerationModeMismatchStrategy;
+use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+use crate::errors::artcraft_router_error::ArtcraftRouterError;
+use crate::errors::client_error::ClientError;
+use crate::generate::generate_image::generate_image_request::GenerateImageRequest;
+use artcraft_api_defs::generate::image::text::generate_flux_1_dev_text_to_image::{
+  GenerateFlux1DevTextToImageAspectRatio, GenerateFlux1DevTextToImageNumImages,
+};
+
+#[derive(Debug, Clone)]
+pub struct PlanArtcraftFlux1Dev<'a> {
+  pub prompt: Option<&'a str>,
+  pub aspect_ratio: Option<GenerateFlux1DevTextToImageAspectRatio>,
+  pub num_images: GenerateFlux1DevTextToImageNumImages,
+  pub idempotency_token: String,
+}
+
+pub fn plan_generate_image_artcraft_flux_1_dev<'a>(
+  request: &'a GenerateImageRequest<'a>,
+) -> Result<PlanArtcraftFlux1Dev<'a>, ArtcraftRouterError> {
+  // Flux 1 Dev is text-to-image only. Abort if image inputs are provided and
+  // the caller has opted into strict mode.
+  if request.image_inputs.is_some() {
+    if let Some(GenerationModeMismatchStrategy::AbortGeneration) = request.generation_mode_mismatch_strategy {
+      return Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+        field: "image_inputs",
+        value: "Flux 1 Dev is a text-to-image model and does not support image editing".to_string(),
+      }));
+    }
+    // None or GenerateAnyway: silently ignore image inputs
+  }
+
+  let strategy = request.request_mismatch_mitigation_strategy;
+  let aspect_ratio = plan_aspect_ratio(request.aspect_ratio, strategy)?;
+  let num_images = plan_num_images(request.image_batch_count, strategy)?;
+
+  Ok(PlanArtcraftFlux1Dev {
+    prompt: request.prompt,
+    aspect_ratio,
+    num_images,
+    idempotency_token: request.get_or_generate_idempotency_token(),
+  })
+}
+
+// Flux 1 Dev supported aspect ratios:
+//   Square, SquareHd, LandscapeFourByThree, LandscapeSixteenByNine,
+//   PortraitThreeByFour, PortraitNineBySixteen
+fn plan_aspect_ratio(
+  aspect_ratio: Option<CommonAspectRatio>,
+  strategy: RequestMismatchMitigationStrategy,
+) -> Result<Option<GenerateFlux1DevTextToImageAspectRatio>, ArtcraftRouterError> {
+  use GenerateFlux1DevTextToImageAspectRatio as FlAr;
+  match aspect_ratio {
+    None => Ok(None),
+
+    // Auto: not valid for text-to-image; fall back to square
+    Some(CommonAspectRatio::Auto)
+    | Some(CommonAspectRatio::Auto2k)
+    | Some(CommonAspectRatio::Auto4k) => Ok(Some(FlAr::Square)),
+
+    // Direct mappings
+    Some(CommonAspectRatio::Square) => Ok(Some(FlAr::Square)),
+    Some(CommonAspectRatio::SquareHd) => Ok(Some(FlAr::SquareHd)),
+    Some(CommonAspectRatio::WideFourByThree) | Some(CommonAspectRatio::WideThreeByTwo) => {
+      Ok(Some(FlAr::LandscapeFourByThree))
+    }
+    Some(CommonAspectRatio::WideSixteenByNine) | Some(CommonAspectRatio::Wide) | Some(CommonAspectRatio::WideTwentyOneByNine) => {
+      Ok(Some(FlAr::LandscapeSixteenByNine))
+    }
+    Some(CommonAspectRatio::TallThreeByFour)
+    | Some(CommonAspectRatio::TallTwoByThree)
+    | Some(CommonAspectRatio::WideFiveByFour) => Ok(Some(FlAr::PortraitThreeByFour)),
+    Some(CommonAspectRatio::TallNineBySixteen) | Some(CommonAspectRatio::Tall) | Some(CommonAspectRatio::TallNineByTwentyOne) => {
+      Ok(Some(FlAr::PortraitNineBySixteen))
+    }
+
+    // Mismatch — TallFourByFive maps to nearest (LandscapeFourByThree per existing desktop behavior)
+    Some(unsupported) => match strategy {
+      RequestMismatchMitigationStrategy::ErrorOut => {
+        Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+          field: "aspect_ratio",
+          value: format!("{:?}", unsupported),
+        }))
+      }
+      RequestMismatchMitigationStrategy::PayMoreUpgrade
+      | RequestMismatchMitigationStrategy::PayLessDowngrade => {
+        Ok(Some(nearest_aspect_ratio(unsupported)))
+      }
+    },
+  }
+}
+
+fn nearest_aspect_ratio(aspect_ratio: CommonAspectRatio) -> GenerateFlux1DevTextToImageAspectRatio {
+  use GenerateFlux1DevTextToImageAspectRatio as FlAr;
+  match aspect_ratio {
+    // TallFourByFive (0.8) — nearest is LandscapeFourByThree per existing desktop behavior
+    CommonAspectRatio::TallFourByFive => FlAr::LandscapeFourByThree,
+    _ => FlAr::Square,
+  }
+}
+
+fn plan_num_images(
+  image_batch_count: Option<u16>,
+  strategy: RequestMismatchMitigationStrategy,
+) -> Result<GenerateFlux1DevTextToImageNumImages, ArtcraftRouterError> {
+  use GenerateFlux1DevTextToImageNumImages as FlN;
+  let count = image_batch_count.unwrap_or(1);
+  match count {
+    0 => Err(ArtcraftRouterError::Client(ClientError::UserRequestedZeroGenerations)),
+    1 => Ok(FlN::One),
+    2 => Ok(FlN::Two),
+    3 => Ok(FlN::Three),
+    4 => Ok(FlN::Four),
+    _ => match strategy {
+      RequestMismatchMitigationStrategy::ErrorOut => {
+        Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+          field: "image_batch_count",
+          value: format!("{}", count),
+        }))
+      }
+      RequestMismatchMitigationStrategy::PayMoreUpgrade
+      | RequestMismatchMitigationStrategy::PayLessDowngrade => Ok(FlN::Four),
+    },
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+  use crate::api::common_aspect_ratio::CommonAspectRatio;
+  use crate::api::image_list_ref::ImageListRef;
+  use crate::client::generation_mode_mismatch_strategy::GenerationModeMismatchStrategy;
+  use crate::errors::artcraft_router_error::ArtcraftRouterError;
+  use crate::errors::client_error::ClientError;
+  use crate::generate::generate_image::generate_image_request::GenerateImageRequest;
+  use crate::generate::generate_image::image_generation_plan::ImageGenerationPlan;
+  use crate::test_helpers::base_flux_1_dev_image_request;
+  use artcraft_api_defs::generate::image::text::generate_flux_1_dev_text_to_image::{
+    GenerateFlux1DevTextToImageAspectRatio as FlAr,
+    GenerateFlux1DevTextToImageNumImages as FlN,
+  };
+
+  // ── Generation mode mismatch ─────────────────────────────────────────────
+
+  #[test]
+  fn image_inputs_with_abort_returns_error() {
+    let tokens = vec![];
+    let request = GenerateImageRequest {
+      image_inputs: Some(ImageListRef::MediaFileTokens(&tokens)),
+      generation_mode_mismatch_strategy: Some(GenerationModeMismatchStrategy::AbortGeneration),
+      ..base_flux_1_dev_image_request()
+    };
+    let result = request.build();
+    assert!(matches!(
+      result,
+      Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption { field: "image_inputs", .. }))
+    ));
+  }
+
+  #[test]
+  fn image_inputs_with_generate_anyway_succeeds() {
+    let tokens = vec![];
+    let request = GenerateImageRequest {
+      image_inputs: Some(ImageListRef::MediaFileTokens(&tokens)),
+      generation_mode_mismatch_strategy: Some(GenerationModeMismatchStrategy::GenerateAnyway),
+      ..base_flux_1_dev_image_request()
+    };
+    assert!(request.build().is_ok());
+  }
+
+  #[test]
+  fn image_inputs_with_none_strategy_succeeds() {
+    let tokens = vec![];
+    let request = GenerateImageRequest {
+      image_inputs: Some(ImageListRef::MediaFileTokens(&tokens)),
+      generation_mode_mismatch_strategy: None,
+      ..base_flux_1_dev_image_request()
+    };
+    assert!(request.build().is_ok());
+  }
+
+  // ── Aspect ratio ─────────────────────────────────────────────────────────
+
+  #[test]
+  fn aspect_ratio_none_is_none() {
+    let request = GenerateImageRequest { aspect_ratio: None, ..base_flux_1_dev_image_request() };
+    let ImageGenerationPlan::ArtcraftFlux1Dev(plan) = request.build().unwrap() else { panic!("expected ArtcraftFlux1Dev") };
+    assert!(plan.aspect_ratio.is_none());
+  }
+
+  #[test]
+  fn aspect_ratio_auto_falls_back_to_square() {
+    for ar in [CommonAspectRatio::Auto, CommonAspectRatio::Auto2k, CommonAspectRatio::Auto4k] {
+      let request = GenerateImageRequest { aspect_ratio: Some(ar), ..base_flux_1_dev_image_request() };
+      let ImageGenerationPlan::ArtcraftFlux1Dev(plan) = request.build().unwrap() else { panic!("expected ArtcraftFlux1Dev") };
+      assert!(matches!(plan.aspect_ratio, Some(FlAr::Square)), "expected Square for {:?}", ar);
+    }
+  }
+
+  #[test]
+  fn aspect_ratio_direct_mappings() {
+    let cases = [
+      (CommonAspectRatio::Square, FlAr::Square),
+      (CommonAspectRatio::SquareHd, FlAr::SquareHd),
+      (CommonAspectRatio::WideFourByThree, FlAr::LandscapeFourByThree),
+      (CommonAspectRatio::WideThreeByTwo, FlAr::LandscapeFourByThree),
+      (CommonAspectRatio::WideSixteenByNine, FlAr::LandscapeSixteenByNine),
+      (CommonAspectRatio::Wide, FlAr::LandscapeSixteenByNine),
+      (CommonAspectRatio::WideTwentyOneByNine, FlAr::LandscapeSixteenByNine),
+      (CommonAspectRatio::TallThreeByFour, FlAr::PortraitThreeByFour),
+      (CommonAspectRatio::TallTwoByThree, FlAr::PortraitThreeByFour),
+      (CommonAspectRatio::WideFiveByFour, FlAr::PortraitThreeByFour),
+      (CommonAspectRatio::TallNineBySixteen, FlAr::PortraitNineBySixteen),
+      (CommonAspectRatio::Tall, FlAr::PortraitNineBySixteen),
+      (CommonAspectRatio::TallNineByTwentyOne, FlAr::PortraitNineBySixteen),
+    ];
+    for (common, expected) in cases {
+      let request = GenerateImageRequest { aspect_ratio: Some(common), ..base_flux_1_dev_image_request() };
+      let ImageGenerationPlan::ArtcraftFlux1Dev(plan) = request.build().unwrap() else { panic!("expected ArtcraftFlux1Dev") };
+      assert!(
+        matches!(plan.aspect_ratio, Some(ar) if std::mem::discriminant(&ar) == std::mem::discriminant(&expected)),
+        "expected {:?} for {:?}", expected, common,
+      );
+    }
+  }
+
+  #[test]
+  fn aspect_ratio_unsupported_error_out() {
+    let request = GenerateImageRequest {
+      aspect_ratio: Some(CommonAspectRatio::TallFourByFive),
+      request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+      ..base_flux_1_dev_image_request()
+    };
+    let result = request.build();
+    assert!(matches!(
+      result,
+      Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption { .. }))
+    ));
+  }
+
+  #[test]
+  fn aspect_ratio_unsupported_nearest_match() {
+    for strategy in [
+      RequestMismatchMitigationStrategy::PayMoreUpgrade,
+      RequestMismatchMitigationStrategy::PayLessDowngrade,
+    ] {
+      let request = GenerateImageRequest {
+        aspect_ratio: Some(CommonAspectRatio::TallFourByFive),
+        request_mismatch_mitigation_strategy: strategy,
+        ..base_flux_1_dev_image_request()
+      };
+      let ImageGenerationPlan::ArtcraftFlux1Dev(plan) = request.build().unwrap() else { panic!("expected ArtcraftFlux1Dev") };
+      assert!(
+        matches!(plan.aspect_ratio, Some(FlAr::LandscapeFourByThree)),
+        "expected LandscapeFourByThree nearest match with {:?}", strategy,
+      );
+    }
+  }
+
+  // ── Num images ───────────────────────────────────────────────────────────
+
+  #[test]
+  fn num_images_zero_is_always_error() {
+    for strategy in [
+      RequestMismatchMitigationStrategy::ErrorOut,
+      RequestMismatchMitigationStrategy::PayMoreUpgrade,
+      RequestMismatchMitigationStrategy::PayLessDowngrade,
+    ] {
+      let request = GenerateImageRequest {
+        image_batch_count: Some(0),
+        request_mismatch_mitigation_strategy: strategy,
+        ..base_flux_1_dev_image_request()
+      };
+      assert!(matches!(
+        request.build(),
+        Err(ArtcraftRouterError::Client(ClientError::UserRequestedZeroGenerations))
+      ));
+    }
+  }
+
+  #[test]
+  fn num_images_direct_mapping() {
+    let cases = [(1, FlN::One), (2, FlN::Two), (3, FlN::Three), (4, FlN::Four)];
+    for (count, expected) in cases {
+      let request = GenerateImageRequest { image_batch_count: Some(count), ..base_flux_1_dev_image_request() };
+      let ImageGenerationPlan::ArtcraftFlux1Dev(plan) = request.build().unwrap() else { panic!("expected ArtcraftFlux1Dev") };
+      assert!(
+        std::mem::discriminant(&plan.num_images) == std::mem::discriminant(&expected),
+        "expected {:?} for count {}", expected, count,
+      );
+    }
+  }
+
+  #[test]
+  fn num_images_out_of_range_error_out() {
+    let request = GenerateImageRequest {
+      image_batch_count: Some(5),
+      request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+      ..base_flux_1_dev_image_request()
+    };
+    assert!(matches!(
+      request.build(),
+      Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption { .. }))
+    ));
+  }
+
+  #[test]
+  fn num_images_out_of_range_clamps_to_four() {
+    for strategy in [
+      RequestMismatchMitigationStrategy::PayMoreUpgrade,
+      RequestMismatchMitigationStrategy::PayLessDowngrade,
+    ] {
+      let request = GenerateImageRequest {
+        image_batch_count: Some(5),
+        request_mismatch_mitigation_strategy: strategy,
+        ..base_flux_1_dev_image_request()
+      };
+      let ImageGenerationPlan::ArtcraftFlux1Dev(plan) = request.build().unwrap() else { panic!("expected ArtcraftFlux1Dev") };
+      assert!(matches!(plan.num_images, FlN::Four));
+    }
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/plan/artcraft/plan_generate_image_artcraft_flux_1_schnell.rs

@@ -0,0 +1,319 @@
+use crate::api::common_aspect_ratio::CommonAspectRatio;
+use crate::client::generation_mode_mismatch_strategy::GenerationModeMismatchStrategy;
+use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+use crate::errors::artcraft_router_error::ArtcraftRouterError;
+use crate::errors::client_error::ClientError;
+use crate::generate::generate_image::generate_image_request::GenerateImageRequest;
+use artcraft_api_defs::generate::image::text::generate_flux_1_schnell_text_to_image::{
+  GenerateFlux1SchnellTextToImageAspectRatio, GenerateFlux1SchnellTextToImageNumImages,
+};
+
+#[derive(Debug, Clone)]
+pub struct PlanArtcraftFlux1Schnell<'a> {
+  pub prompt: Option<&'a str>,
+  pub aspect_ratio: Option<GenerateFlux1SchnellTextToImageAspectRatio>,
+  pub num_images: GenerateFlux1SchnellTextToImageNumImages,
+  pub idempotency_token: String,
+}
+
+pub fn plan_generate_image_artcraft_flux_1_schnell<'a>(
+  request: &'a GenerateImageRequest<'a>,
+) -> Result<PlanArtcraftFlux1Schnell<'a>, ArtcraftRouterError> {
+  // Flux 1 Schnell is text-to-image only. Abort if image inputs are provided and
+  // the caller has opted into strict mode.
+  if request.image_inputs.is_some() {
+    if let Some(GenerationModeMismatchStrategy::AbortGeneration) = request.generation_mode_mismatch_strategy {
+      return Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+        field: "image_inputs",
+        value: "Flux 1 Schnell is a text-to-image model and does not support image editing".to_string(),
+      }));
+    }
+    // None or GenerateAnyway: silently ignore image inputs
+  }
+
+  let strategy = request.request_mismatch_mitigation_strategy;
+  let aspect_ratio = plan_aspect_ratio(request.aspect_ratio, strategy)?;
+  let num_images = plan_num_images(request.image_batch_count, strategy)?;
+
+  Ok(PlanArtcraftFlux1Schnell {
+    prompt: request.prompt,
+    aspect_ratio,
+    num_images,
+    idempotency_token: request.get_or_generate_idempotency_token(),
+  })
+}
+
+// Flux 1 Schnell supported aspect ratios (identical to Flux 1 Dev):
+//   Square, SquareHd, LandscapeFourByThree, LandscapeSixteenByNine,
+//   PortraitThreeByFour, PortraitNineBySixteen
+fn plan_aspect_ratio(
+  aspect_ratio: Option<CommonAspectRatio>,
+  strategy: RequestMismatchMitigationStrategy,
+) -> Result<Option<GenerateFlux1SchnellTextToImageAspectRatio>, ArtcraftRouterError> {
+  use GenerateFlux1SchnellTextToImageAspectRatio as FlAr;
+  match aspect_ratio {
+    None => Ok(None),
+
+    // Auto: not valid for text-to-image; fall back to square
+    Some(CommonAspectRatio::Auto)
+    | Some(CommonAspectRatio::Auto2k)
+    | Some(CommonAspectRatio::Auto4k) => Ok(Some(FlAr::Square)),
+
+    // Direct mappings
+    Some(CommonAspectRatio::Square) => Ok(Some(FlAr::Square)),
+    Some(CommonAspectRatio::SquareHd) => Ok(Some(FlAr::SquareHd)),
+    Some(CommonAspectRatio::WideFourByThree) | Some(CommonAspectRatio::WideThreeByTwo) => {
+      Ok(Some(FlAr::LandscapeFourByThree))
+    }
+    Some(CommonAspectRatio::WideSixteenByNine) | Some(CommonAspectRatio::Wide) | Some(CommonAspectRatio::WideTwentyOneByNine) => {
+      Ok(Some(FlAr::LandscapeSixteenByNine))
+    }
+    Some(CommonAspectRatio::TallThreeByFour)
+    | Some(CommonAspectRatio::TallTwoByThree)
+    | Some(CommonAspectRatio::WideFiveByFour) => Ok(Some(FlAr::PortraitThreeByFour)),
+    Some(CommonAspectRatio::TallNineBySixteen) | Some(CommonAspectRatio::Tall) | Some(CommonAspectRatio::TallNineByTwentyOne) => {
+      Ok(Some(FlAr::PortraitNineBySixteen))
+    }
+
+    // Mismatch — TallFourByFive maps to nearest (LandscapeFourByThree per existing desktop behavior)
+    Some(unsupported) => match strategy {
+      RequestMismatchMitigationStrategy::ErrorOut => {
+        Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+          field: "aspect_ratio",
+          value: format!("{:?}", unsupported),
+        }))
+      }
+      RequestMismatchMitigationStrategy::PayMoreUpgrade
+      | RequestMismatchMitigationStrategy::PayLessDowngrade => {
+        Ok(Some(nearest_aspect_ratio(unsupported)))
+      }
+    },
+  }
+}
+
+fn nearest_aspect_ratio(aspect_ratio: CommonAspectRatio) -> GenerateFlux1SchnellTextToImageAspectRatio {
+  use GenerateFlux1SchnellTextToImageAspectRatio as FlAr;
+  match aspect_ratio {
+    // TallFourByFive (0.8) — nearest is LandscapeFourByThree per existing desktop behavior
+    CommonAspectRatio::TallFourByFive => FlAr::LandscapeFourByThree,
+    _ => FlAr::Square,
+  }
+}
+
+fn plan_num_images(
+  image_batch_count: Option<u16>,
+  strategy: RequestMismatchMitigationStrategy,
+) -> Result<GenerateFlux1SchnellTextToImageNumImages, ArtcraftRouterError> {
+  use GenerateFlux1SchnellTextToImageNumImages as FlN;
+  let count = image_batch_count.unwrap_or(1);
+  match count {
+    0 => Err(ArtcraftRouterError::Client(ClientError::UserRequestedZeroGenerations)),
+    1 => Ok(FlN::One),
+    2 => Ok(FlN::Two),
+    3 => Ok(FlN::Three),
+    4 => Ok(FlN::Four),
+    _ => match strategy {
+      RequestMismatchMitigationStrategy::ErrorOut => {
+        Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+          field: "image_batch_count",
+          value: format!("{}", count),
+        }))
+      }
+      RequestMismatchMitigationStrategy::PayMoreUpgrade
+      | RequestMismatchMitigationStrategy::PayLessDowngrade => Ok(FlN::Four),
+    },
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+  use crate::api::common_aspect_ratio::CommonAspectRatio;
+  use crate::api::image_list_ref::ImageListRef;
+  use crate::client::generation_mode_mismatch_strategy::GenerationModeMismatchStrategy;
+  use crate::errors::artcraft_router_error::ArtcraftRouterError;
+  use crate::errors::client_error::ClientError;
+  use crate::generate::generate_image::generate_image_request::GenerateImageRequest;
+  use crate::generate::generate_image::image_generation_plan::ImageGenerationPlan;
+  use crate::test_helpers::base_flux_1_schnell_image_request;
+  use artcraft_api_defs::generate::image::text::generate_flux_1_schnell_text_to_image::{
+    GenerateFlux1SchnellTextToImageAspectRatio as FlAr,
+    GenerateFlux1SchnellTextToImageNumImages as FlN,
+  };
+
+  // ── Generation mode mismatch ─────────────────────────────────────────────
+
+  #[test]
+  fn image_inputs_with_abort_returns_error() {
+    let tokens = vec![];
+    let request = GenerateImageRequest {
+      image_inputs: Some(ImageListRef::MediaFileTokens(&tokens)),
+      generation_mode_mismatch_strategy: Some(GenerationModeMismatchStrategy::AbortGeneration),
+      ..base_flux_1_schnell_image_request()
+    };
+    let result = request.build();
+    assert!(matches!(
+      result,
+      Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption { field: "image_inputs", .. }))
+    ));
+  }
+
+  #[test]
+  fn image_inputs_with_generate_anyway_succeeds() {
+    let tokens = vec![];
+    let request = GenerateImageRequest {
+      image_inputs: Some(ImageListRef::MediaFileTokens(&tokens)),
+      generation_mode_mismatch_strategy: Some(GenerationModeMismatchStrategy::GenerateAnyway),
+      ..base_flux_1_schnell_image_request()
+    };
+    assert!(request.build().is_ok());
+  }
+
+  #[test]
+  fn image_inputs_with_none_strategy_succeeds() {
+    let tokens = vec![];
+    let request = GenerateImageRequest {
+      image_inputs: Some(ImageListRef::MediaFileTokens(&tokens)),
+      generation_mode_mismatch_strategy: None,
+      ..base_flux_1_schnell_image_request()
+    };
+    assert!(request.build().is_ok());
+  }
+
+  // ── Aspect ratio ─────────────────────────────────────────────────────────
+
+  #[test]
+  fn aspect_ratio_none_is_none() {
+    let request = GenerateImageRequest { aspect_ratio: None, ..base_flux_1_schnell_image_request() };
+    let ImageGenerationPlan::ArtcraftFlux1Schnell(plan) = request.build().unwrap() else { panic!("expected ArtcraftFlux1Schnell") };
+    assert!(plan.aspect_ratio.is_none());
+  }
+
+  #[test]
+  fn aspect_ratio_auto_falls_back_to_square() {
+    for ar in [CommonAspectRatio::Auto, CommonAspectRatio::Auto2k, CommonAspectRatio::Auto4k] {
+      let request = GenerateImageRequest { aspect_ratio: Some(ar), ..base_flux_1_schnell_image_request() };
+      let ImageGenerationPlan::ArtcraftFlux1Schnell(plan) = request.build().unwrap() else { panic!("expected ArtcraftFlux1Schnell") };
+      assert!(matches!(plan.aspect_ratio, Some(FlAr::Square)), "expected Square for {:?}", ar);
+    }
+  }
+
+  #[test]
+  fn aspect_ratio_direct_mappings() {
+    let cases = [
+      (CommonAspectRatio::Square, FlAr::Square),
+      (CommonAspectRatio::SquareHd, FlAr::SquareHd),
+      (CommonAspectRatio::WideFourByThree, FlAr::LandscapeFourByThree),
+      (CommonAspectRatio::WideThreeByTwo, FlAr::LandscapeFourByThree),
+      (CommonAspectRatio::WideSixteenByNine, FlAr::LandscapeSixteenByNine),
+      (CommonAspectRatio::Wide, FlAr::LandscapeSixteenByNine),
+      (CommonAspectRatio::WideTwentyOneByNine, FlAr::LandscapeSixteenByNine),
+      (CommonAspectRatio::TallThreeByFour, FlAr::PortraitThreeByFour),
+      (CommonAspectRatio::TallTwoByThree, FlAr::PortraitThreeByFour),
+      (CommonAspectRatio::WideFiveByFour, FlAr::PortraitThreeByFour),
+      (CommonAspectRatio::TallNineBySixteen, FlAr::PortraitNineBySixteen),
+      (CommonAspectRatio::Tall, FlAr::PortraitNineBySixteen),
+      (CommonAspectRatio::TallNineByTwentyOne, FlAr::PortraitNineBySixteen),
+    ];
+    for (common, expected) in cases {
+      let request = GenerateImageRequest { aspect_ratio: Some(common), ..base_flux_1_schnell_image_request() };
+      let ImageGenerationPlan::ArtcraftFlux1Schnell(plan) = request.build().unwrap() else { panic!("expected ArtcraftFlux1Schnell") };
+      assert!(
+        matches!(plan.aspect_ratio, Some(ar) if std::mem::discriminant(&ar) == std::mem::discriminant(&expected)),
+        "expected {:?} for {:?}", expected, common,
+      );
+    }
+  }
+
+  #[test]
+  fn aspect_ratio_unsupported_error_out() {
+    let request = GenerateImageRequest {
+      aspect_ratio: Some(CommonAspectRatio::TallFourByFive),
+      request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+      ..base_flux_1_schnell_image_request()
+    };
+    assert!(matches!(
+      request.build(),
+      Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption { .. }))
+    ));
+  }
+
+  #[test]
+  fn aspect_ratio_unsupported_nearest_match() {
+    for strategy in [
+      RequestMismatchMitigationStrategy::PayMoreUpgrade,
+      RequestMismatchMitigationStrategy::PayLessDowngrade,
+    ] {
+      let request = GenerateImageRequest {
+        aspect_ratio: Some(CommonAspectRatio::TallFourByFive),
+        request_mismatch_mitigation_strategy: strategy,
+        ..base_flux_1_schnell_image_request()
+      };
+      let ImageGenerationPlan::ArtcraftFlux1Schnell(plan) = request.build().unwrap() else { panic!("expected ArtcraftFlux1Schnell") };
+      assert!(matches!(plan.aspect_ratio, Some(FlAr::LandscapeFourByThree)));
+    }
+  }
+
+  // ── Num images ───────────────────────────────────────────────────────────
+
+  #[test]
+  fn num_images_zero_is_always_error() {
+    for strategy in [
+      RequestMismatchMitigationStrategy::ErrorOut,
+      RequestMismatchMitigationStrategy::PayMoreUpgrade,
+      RequestMismatchMitigationStrategy::PayLessDowngrade,
+    ] {
+      let request = GenerateImageRequest {
+        image_batch_count: Some(0),
+        request_mismatch_mitigation_strategy: strategy,
+        ..base_flux_1_schnell_image_request()
+      };
+      assert!(matches!(
+        request.build(),
+        Err(ArtcraftRouterError::Client(ClientError::UserRequestedZeroGenerations))
+      ));
+    }
+  }
+
+  #[test]
+  fn num_images_direct_mapping() {
+    let cases = [(1, FlN::One), (2, FlN::Two), (3, FlN::Three), (4, FlN::Four)];
+    for (count, expected) in cases {
+      let request = GenerateImageRequest { image_batch_count: Some(count), ..base_flux_1_schnell_image_request() };
+      let ImageGenerationPlan::ArtcraftFlux1Schnell(plan) = request.build().unwrap() else { panic!("expected ArtcraftFlux1Schnell") };
+      assert!(
+        std::mem::discriminant(&plan.num_images) == std::mem::discriminant(&expected),
+        "expected {:?} for count {}", expected, count,
+      );
+    }
+  }
+
+  #[test]
+  fn num_images_out_of_range_error_out() {
+    let request = GenerateImageRequest {
+      image_batch_count: Some(5),
+      request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+      ..base_flux_1_schnell_image_request()
+    };
+    assert!(matches!(
+      request.build(),
+      Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption { .. }))
+    ));
+  }
+
+  #[test]
+  fn num_images_out_of_range_clamps_to_four() {
+    for strategy in [
+      RequestMismatchMitigationStrategy::PayMoreUpgrade,
+      RequestMismatchMitigationStrategy::PayLessDowngrade,
+    ] {
+      let request = GenerateImageRequest {
+        image_batch_count: Some(5),
+        request_mismatch_mitigation_strategy: strategy,
+        ..base_flux_1_schnell_image_request()
+      };
+      let ImageGenerationPlan::ArtcraftFlux1Schnell(plan) = request.build().unwrap() else { panic!("expected ArtcraftFlux1Schnell") };
+      assert!(matches!(plan.num_images, FlN::Four));
+    }
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/plan/artcraft/plan_generate_image_artcraft_flux_pro_1p1.rs

@@ -0,0 +1,323 @@
+use crate::api::common_aspect_ratio::CommonAspectRatio;
+use crate::client::generation_mode_mismatch_strategy::GenerationModeMismatchStrategy;
+use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+use crate::errors::artcraft_router_error::ArtcraftRouterError;
+use crate::errors::client_error::ClientError;
+use crate::generate::generate_image::generate_image_request::GenerateImageRequest;
+use artcraft_api_defs::generate::image::text::generate_flux_pro_11_text_to_image::{
+  GenerateFluxPro11TextToImageAspectRatio, GenerateFluxPro11TextToImageNumImages,
+};
+
+#[derive(Debug, Clone)]
+pub struct PlanArtcraftFluxPro11<'a> {
+  pub prompt: Option<&'a str>,
+  pub aspect_ratio: Option<GenerateFluxPro11TextToImageAspectRatio>,
+  pub num_images: GenerateFluxPro11TextToImageNumImages,
+  pub idempotency_token: String,
+}
+
+pub fn plan_generate_image_artcraft_flux_pro_1p1<'a>(
+  request: &'a GenerateImageRequest<'a>,
+) -> Result<PlanArtcraftFluxPro11<'a>, ArtcraftRouterError> {
+  // Flux Pro 1.1 is text-to-image only. Abort if image inputs are provided and
+  // the caller has opted into strict mode.
+  if request.image_inputs.is_some() {
+    if let Some(GenerationModeMismatchStrategy::AbortGeneration) = request.generation_mode_mismatch_strategy {
+      return Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+        field: "image_inputs",
+        value: "Flux Pro 1.1 is a text-to-image model and does not support image editing".to_string(),
+      }));
+    }
+    // None or GenerateAnyway: silently ignore image inputs
+  }
+
+  let strategy = request.request_mismatch_mitigation_strategy;
+  let aspect_ratio = plan_aspect_ratio(request.aspect_ratio, strategy)?;
+  let num_images = plan_num_images(request.image_batch_count, strategy)?;
+
+  Ok(PlanArtcraftFluxPro11 {
+    prompt: request.prompt,
+    aspect_ratio,
+    num_images,
+    idempotency_token: request.get_or_generate_idempotency_token(),
+  })
+}
+
+// Flux Pro 1.1 supported aspect ratios (no SquareHd):
+//   Square, LandscapeFourByThree, LandscapeSixteenByNine,
+//   PortraitThreeByFour, PortraitNineBySixteen
+fn plan_aspect_ratio(
+  aspect_ratio: Option<CommonAspectRatio>,
+  strategy: RequestMismatchMitigationStrategy,
+) -> Result<Option<GenerateFluxPro11TextToImageAspectRatio>, ArtcraftRouterError> {
+  use GenerateFluxPro11TextToImageAspectRatio as FlAr;
+  match aspect_ratio {
+    None => Ok(None),
+
+    // Auto and SquareHd: no direct equivalent; fall back to square
+    Some(CommonAspectRatio::Auto)
+    | Some(CommonAspectRatio::Auto2k)
+    | Some(CommonAspectRatio::Auto4k)
+    | Some(CommonAspectRatio::SquareHd) => Ok(Some(FlAr::Square)),
+
+    // Direct mappings
+    Some(CommonAspectRatio::Square) => Ok(Some(FlAr::Square)),
+    Some(CommonAspectRatio::WideFourByThree) | Some(CommonAspectRatio::WideThreeByTwo) => {
+      Ok(Some(FlAr::LandscapeFourByThree))
+    }
+    Some(CommonAspectRatio::WideSixteenByNine) | Some(CommonAspectRatio::Wide) | Some(CommonAspectRatio::WideTwentyOneByNine) => {
+      Ok(Some(FlAr::LandscapeSixteenByNine))
+    }
+    Some(CommonAspectRatio::TallThreeByFour)
+    | Some(CommonAspectRatio::TallTwoByThree)
+    | Some(CommonAspectRatio::WideFiveByFour) => Ok(Some(FlAr::PortraitThreeByFour)),
+    Some(CommonAspectRatio::TallNineBySixteen) | Some(CommonAspectRatio::Tall) | Some(CommonAspectRatio::TallNineByTwentyOne) => {
+      Ok(Some(FlAr::PortraitNineBySixteen))
+    }
+
+    // Mismatch — TallFourByFive maps to nearest (LandscapeFourByThree per existing desktop behavior)
+    Some(unsupported) => match strategy {
+      RequestMismatchMitigationStrategy::ErrorOut => {
+        Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+          field: "aspect_ratio",
+          value: format!("{:?}", unsupported),
+        }))
+      }
+      RequestMismatchMitigationStrategy::PayMoreUpgrade
+      | RequestMismatchMitigationStrategy::PayLessDowngrade => {
+        Ok(Some(nearest_aspect_ratio(unsupported)))
+      }
+    },
+  }
+}
+
+fn nearest_aspect_ratio(aspect_ratio: CommonAspectRatio) -> GenerateFluxPro11TextToImageAspectRatio {
+  use GenerateFluxPro11TextToImageAspectRatio as FlAr;
+  match aspect_ratio {
+    // TallFourByFive (0.8) — nearest is LandscapeFourByThree per existing desktop behavior
+    CommonAspectRatio::TallFourByFive => FlAr::LandscapeFourByThree,
+    _ => FlAr::Square,
+  }
+}
+
+fn plan_num_images(
+  image_batch_count: Option<u16>,
+  strategy: RequestMismatchMitigationStrategy,
+) -> Result<GenerateFluxPro11TextToImageNumImages, ArtcraftRouterError> {
+  use GenerateFluxPro11TextToImageNumImages as FlN;
+  let count = image_batch_count.unwrap_or(1);
+  match count {
+    0 => Err(ArtcraftRouterError::Client(ClientError::UserRequestedZeroGenerations)),
+    1 => Ok(FlN::One),
+    2 => Ok(FlN::Two),
+    3 => Ok(FlN::Three),
+    4 => Ok(FlN::Four),
+    _ => match strategy {
+      RequestMismatchMitigationStrategy::ErrorOut => {
+        Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+          field: "image_batch_count",
+          value: format!("{}", count),
+        }))
+      }
+      RequestMismatchMitigationStrategy::PayMoreUpgrade
+      | RequestMismatchMitigationStrategy::PayLessDowngrade => Ok(FlN::Four),
+    },
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+  use crate::api::common_aspect_ratio::CommonAspectRatio;
+  use crate::api::image_list_ref::ImageListRef;
+  use crate::client::generation_mode_mismatch_strategy::GenerationModeMismatchStrategy;
+  use crate::errors::artcraft_router_error::ArtcraftRouterError;
+  use crate::errors::client_error::ClientError;
+  use crate::generate::generate_image::generate_image_request::GenerateImageRequest;
+  use crate::generate::generate_image::image_generation_plan::ImageGenerationPlan;
+  use crate::test_helpers::base_flux_pro_1p1_image_request;
+  use artcraft_api_defs::generate::image::text::generate_flux_pro_11_text_to_image::{
+    GenerateFluxPro11TextToImageAspectRatio as FlAr,
+    GenerateFluxPro11TextToImageNumImages as FlN,
+  };
+
+  // ── Generation mode mismatch ─────────────────────────────────────────────
+
+  #[test]
+  fn image_inputs_with_abort_returns_error() {
+    let tokens = vec![];
+    let request = GenerateImageRequest {
+      image_inputs: Some(ImageListRef::MediaFileTokens(&tokens)),
+      generation_mode_mismatch_strategy: Some(GenerationModeMismatchStrategy::AbortGeneration),
+      ..base_flux_pro_1p1_image_request()
+    };
+    let result = request.build();
+    assert!(matches!(
+      result,
+      Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption { field: "image_inputs", .. }))
+    ));
+  }
+
+  #[test]
+  fn image_inputs_with_generate_anyway_succeeds() {
+    let tokens = vec![];
+    let request = GenerateImageRequest {
+      image_inputs: Some(ImageListRef::MediaFileTokens(&tokens)),
+      generation_mode_mismatch_strategy: Some(GenerationModeMismatchStrategy::GenerateAnyway),
+      ..base_flux_pro_1p1_image_request()
+    };
+    assert!(request.build().is_ok());
+  }
+
+  #[test]
+  fn image_inputs_with_none_strategy_succeeds() {
+    let tokens = vec![];
+    let request = GenerateImageRequest {
+      image_inputs: Some(ImageListRef::MediaFileTokens(&tokens)),
+      generation_mode_mismatch_strategy: None,
+      ..base_flux_pro_1p1_image_request()
+    };
+    assert!(request.build().is_ok());
+  }
+
+  // ── Aspect ratio ─────────────────────────────────────────────────────────
+
+  #[test]
+  fn aspect_ratio_none_is_none() {
+    let request = GenerateImageRequest { aspect_ratio: None, ..base_flux_pro_1p1_image_request() };
+    let ImageGenerationPlan::ArtcraftFluxPro11(plan) = request.build().unwrap() else { panic!("expected ArtcraftFluxPro11") };
+    assert!(plan.aspect_ratio.is_none());
+  }
+
+  #[test]
+  fn aspect_ratio_auto_and_square_hd_fall_back_to_square() {
+    for ar in [
+      CommonAspectRatio::Auto,
+      CommonAspectRatio::Auto2k,
+      CommonAspectRatio::Auto4k,
+      CommonAspectRatio::SquareHd,
+    ] {
+      let request = GenerateImageRequest { aspect_ratio: Some(ar), ..base_flux_pro_1p1_image_request() };
+      let ImageGenerationPlan::ArtcraftFluxPro11(plan) = request.build().unwrap() else { panic!("expected ArtcraftFluxPro11") };
+      assert!(matches!(plan.aspect_ratio, Some(FlAr::Square)), "expected Square for {:?}", ar);
+    }
+  }
+
+  #[test]
+  fn aspect_ratio_direct_mappings() {
+    let cases = [
+      (CommonAspectRatio::Square, FlAr::Square),
+      (CommonAspectRatio::WideFourByThree, FlAr::LandscapeFourByThree),
+      (CommonAspectRatio::WideThreeByTwo, FlAr::LandscapeFourByThree),
+      (CommonAspectRatio::WideSixteenByNine, FlAr::LandscapeSixteenByNine),
+      (CommonAspectRatio::Wide, FlAr::LandscapeSixteenByNine),
+      (CommonAspectRatio::WideTwentyOneByNine, FlAr::LandscapeSixteenByNine),
+      (CommonAspectRatio::TallThreeByFour, FlAr::PortraitThreeByFour),
+      (CommonAspectRatio::TallTwoByThree, FlAr::PortraitThreeByFour),
+      (CommonAspectRatio::WideFiveByFour, FlAr::PortraitThreeByFour),
+      (CommonAspectRatio::TallNineBySixteen, FlAr::PortraitNineBySixteen),
+      (CommonAspectRatio::Tall, FlAr::PortraitNineBySixteen),
+      (CommonAspectRatio::TallNineByTwentyOne, FlAr::PortraitNineBySixteen),
+    ];
+    for (common, expected) in cases {
+      let request = GenerateImageRequest { aspect_ratio: Some(common), ..base_flux_pro_1p1_image_request() };
+      let ImageGenerationPlan::ArtcraftFluxPro11(plan) = request.build().unwrap() else { panic!("expected ArtcraftFluxPro11") };
+      assert!(
+        matches!(plan.aspect_ratio, Some(ar) if std::mem::discriminant(&ar) == std::mem::discriminant(&expected)),
+        "expected {:?} for {:?}", expected, common,
+      );
+    }
+  }
+
+  #[test]
+  fn aspect_ratio_unsupported_error_out() {
+    let request = GenerateImageRequest {
+      aspect_ratio: Some(CommonAspectRatio::TallFourByFive),
+      request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+      ..base_flux_pro_1p1_image_request()
+    };
+    assert!(matches!(
+      request.build(),
+      Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption { .. }))
+    ));
+  }
+
+  #[test]
+  fn aspect_ratio_unsupported_nearest_match() {
+    for strategy in [
+      RequestMismatchMitigationStrategy::PayMoreUpgrade,
+      RequestMismatchMitigationStrategy::PayLessDowngrade,
+    ] {
+      let request = GenerateImageRequest {
+        aspect_ratio: Some(CommonAspectRatio::TallFourByFive),
+        request_mismatch_mitigation_strategy: strategy,
+        ..base_flux_pro_1p1_image_request()
+      };
+      let ImageGenerationPlan::ArtcraftFluxPro11(plan) = request.build().unwrap() else { panic!("expected ArtcraftFluxPro11") };
+      assert!(matches!(plan.aspect_ratio, Some(FlAr::LandscapeFourByThree)));
+    }
+  }
+
+  // ── Num images ───────────────────────────────────────────────────────────
+
+  #[test]
+  fn num_images_zero_is_always_error() {
+    for strategy in [
+      RequestMismatchMitigationStrategy::ErrorOut,
+      RequestMismatchMitigationStrategy::PayMoreUpgrade,
+      RequestMismatchMitigationStrategy::PayLessDowngrade,
+    ] {
+      let request = GenerateImageRequest {
+        image_batch_count: Some(0),
+        request_mismatch_mitigation_strategy: strategy,
+        ..base_flux_pro_1p1_image_request()
+      };
+      assert!(matches!(
+        request.build(),
+        Err(ArtcraftRouterError::Client(ClientError::UserRequestedZeroGenerations))
+      ));
+    }
+  }
+
+  #[test]
+  fn num_images_direct_mapping() {
+    let cases = [(1, FlN::One), (2, FlN::Two), (3, FlN::Three), (4, FlN::Four)];
+    for (count, expected) in cases {
+      let request = GenerateImageRequest { image_batch_count: Some(count), ..base_flux_pro_1p1_image_request() };
+      let ImageGenerationPlan::ArtcraftFluxPro11(plan) = request.build().unwrap() else { panic!("expected ArtcraftFluxPro11") };
+      assert!(
+        std::mem::discriminant(&plan.num_images) == std::mem::discriminant(&expected),
+        "expected {:?} for count {}", expected, count,
+      );
+    }
+  }
+
+  #[test]
+  fn num_images_out_of_range_error_out() {
+    let request = GenerateImageRequest {
+      image_batch_count: Some(5),
+      request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+      ..base_flux_pro_1p1_image_request()
+    };
+    assert!(matches!(
+      request.build(),
+      Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption { .. }))
+    ));
+  }
+
+  #[test]
+  fn num_images_out_of_range_clamps_to_four() {
+    for strategy in [
+      RequestMismatchMitigationStrategy::PayMoreUpgrade,
+      RequestMismatchMitigationStrategy::PayLessDowngrade,
+    ] {
+      let request = GenerateImageRequest {
+        image_batch_count: Some(5),
+        request_mismatch_mitigation_strategy: strategy,
+        ..base_flux_pro_1p1_image_request()
+      };
+      let ImageGenerationPlan::ArtcraftFluxPro11(plan) = request.build().unwrap() else { panic!("expected ArtcraftFluxPro11") };
+      assert!(matches!(plan.num_images, FlN::Four));
+    }
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/plan/artcraft/plan_generate_image_artcraft_flux_pro_1p1_ultra.rs

@@ -0,0 +1,326 @@
+use crate::api::common_aspect_ratio::CommonAspectRatio;
+use crate::client::generation_mode_mismatch_strategy::GenerationModeMismatchStrategy;
+use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+use crate::errors::artcraft_router_error::ArtcraftRouterError;
+use crate::errors::client_error::ClientError;
+use crate::generate::generate_image::generate_image_request::GenerateImageRequest;
+use artcraft_api_defs::generate::image::text::generate_flux_pro_11_ultra_text_to_image::{
+  GenerateFluxPro11UltraTextToImageAspectRatio, GenerateFluxPro11UltraTextToImageNumImages,
+};
+
+#[derive(Debug, Clone)]
+pub struct PlanArtcraftFluxPro11Ultra<'a> {
+  pub prompt: Option<&'a str>,
+  pub aspect_ratio: Option<GenerateFluxPro11UltraTextToImageAspectRatio>,
+  pub num_images: GenerateFluxPro11UltraTextToImageNumImages,
+  pub idempotency_token: String,
+}
+
+pub fn plan_generate_image_artcraft_flux_pro_1p1_ultra<'a>(
+  request: &'a GenerateImageRequest<'a>,
+) -> Result<PlanArtcraftFluxPro11Ultra<'a>, ArtcraftRouterError> {
+  // Flux Pro 1.1 Ultra is text-to-image only. Abort if image inputs are provided and
+  // the caller has opted into strict mode.
+  if request.image_inputs.is_some() {
+    if let Some(GenerationModeMismatchStrategy::AbortGeneration) = request.generation_mode_mismatch_strategy {
+      return Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+        field: "image_inputs",
+        value: "Flux Pro 1.1 Ultra is a text-to-image model and does not support image editing".to_string(),
+      }));
+    }
+    // None or GenerateAnyway: silently ignore image inputs
+  }
+
+  let strategy = request.request_mismatch_mitigation_strategy;
+  let aspect_ratio = plan_aspect_ratio(request.aspect_ratio, strategy)?;
+  let num_images = plan_num_images(request.image_batch_count, strategy)?;
+
+  Ok(PlanArtcraftFluxPro11Ultra {
+    prompt: request.prompt,
+    aspect_ratio,
+    num_images,
+    idempotency_token: request.get_or_generate_idempotency_token(),
+  })
+}
+
+// Flux Pro 1.1 Ultra supported aspect ratios:
+//   Square, LandscapeThreeByTwo, LandscapeFourByThree, LandscapeSixteenByNine,
+//   LandscapeTwentyOneByNine, PortraitTwoByThree, PortraitThreeByFour,
+//   PortraitNineBySixteen, PortraitNineByTwentyOne
+fn plan_aspect_ratio(
+  aspect_ratio: Option<CommonAspectRatio>,
+  strategy: RequestMismatchMitigationStrategy,
+) -> Result<Option<GenerateFluxPro11UltraTextToImageAspectRatio>, ArtcraftRouterError> {
+  use GenerateFluxPro11UltraTextToImageAspectRatio as FlAr;
+  match aspect_ratio {
+    None => Ok(None),
+
+    // Auto and SquareHd: no direct equivalent; fall back to square
+    Some(CommonAspectRatio::Auto)
+    | Some(CommonAspectRatio::Auto2k)
+    | Some(CommonAspectRatio::Auto4k)
+    | Some(CommonAspectRatio::SquareHd) => Ok(Some(FlAr::Square)),
+
+    // Direct mappings
+    Some(CommonAspectRatio::Square) => Ok(Some(FlAr::Square)),
+    Some(CommonAspectRatio::WideThreeByTwo) => Ok(Some(FlAr::LandscapeThreeByTwo)),
+    Some(CommonAspectRatio::WideFourByThree) => Ok(Some(FlAr::LandscapeFourByThree)),
+    Some(CommonAspectRatio::WideSixteenByNine) | Some(CommonAspectRatio::Wide) => {
+      Ok(Some(FlAr::LandscapeSixteenByNine))
+    }
+    Some(CommonAspectRatio::WideTwentyOneByNine) => Ok(Some(FlAr::LandscapeTwentyOneByNine)),
+    Some(CommonAspectRatio::TallTwoByThree) => Ok(Some(FlAr::PortraitTwoByThree)),
+    Some(CommonAspectRatio::TallThreeByFour) | Some(CommonAspectRatio::WideFiveByFour) => {
+      Ok(Some(FlAr::PortraitThreeByFour))
+    }
+    Some(CommonAspectRatio::TallNineBySixteen) | Some(CommonAspectRatio::Tall) => {
+      Ok(Some(FlAr::PortraitNineBySixteen))
+    }
+    Some(CommonAspectRatio::TallNineByTwentyOne) => Ok(Some(FlAr::PortraitNineByTwentyOne)),
+
+    // Mismatch — TallFourByFive maps to nearest (LandscapeFourByThree per existing desktop behavior)
+    Some(unsupported) => match strategy {
+      RequestMismatchMitigationStrategy::ErrorOut => {
+        Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+          field: "aspect_ratio",
+          value: format!("{:?}", unsupported),
+        }))
+      }
+      RequestMismatchMitigationStrategy::PayMoreUpgrade
+      | RequestMismatchMitigationStrategy::PayLessDowngrade => {
+        Ok(Some(nearest_aspect_ratio(unsupported)))
+      }
+    },
+  }
+}
+
+fn nearest_aspect_ratio(aspect_ratio: CommonAspectRatio) -> GenerateFluxPro11UltraTextToImageAspectRatio {
+  use GenerateFluxPro11UltraTextToImageAspectRatio as FlAr;
+  match aspect_ratio {
+    // TallFourByFive (0.8) — nearest is LandscapeFourByThree per existing desktop behavior
+    CommonAspectRatio::TallFourByFive => FlAr::LandscapeFourByThree,
+    _ => FlAr::Square,
+  }
+}
+
+fn plan_num_images(
+  image_batch_count: Option<u16>,
+  strategy: RequestMismatchMitigationStrategy,
+) -> Result<GenerateFluxPro11UltraTextToImageNumImages, ArtcraftRouterError> {
+  use GenerateFluxPro11UltraTextToImageNumImages as FlN;
+  let count = image_batch_count.unwrap_or(1);
+  match count {
+    0 => Err(ArtcraftRouterError::Client(ClientError::UserRequestedZeroGenerations)),
+    1 => Ok(FlN::One),
+    2 => Ok(FlN::Two),
+    3 => Ok(FlN::Three),
+    4 => Ok(FlN::Four),
+    _ => match strategy {
+      RequestMismatchMitigationStrategy::ErrorOut => {
+        Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+          field: "image_batch_count",
+          value: format!("{}", count),
+        }))
+      }
+      RequestMismatchMitigationStrategy::PayMoreUpgrade
+      | RequestMismatchMitigationStrategy::PayLessDowngrade => Ok(FlN::Four),
+    },
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+  use crate::api::common_aspect_ratio::CommonAspectRatio;
+  use crate::api::image_list_ref::ImageListRef;
+  use crate::client::generation_mode_mismatch_strategy::GenerationModeMismatchStrategy;
+  use crate::errors::artcraft_router_error::ArtcraftRouterError;
+  use crate::errors::client_error::ClientError;
+  use crate::generate::generate_image::generate_image_request::GenerateImageRequest;
+  use crate::generate::generate_image::image_generation_plan::ImageGenerationPlan;
+  use crate::test_helpers::base_flux_pro_1p1_ultra_image_request;
+  use artcraft_api_defs::generate::image::text::generate_flux_pro_11_ultra_text_to_image::{
+    GenerateFluxPro11UltraTextToImageAspectRatio as FlAr,
+    GenerateFluxPro11UltraTextToImageNumImages as FlN,
+  };
+
+  // ── Generation mode mismatch ─────────────────────────────────────────────
+
+  #[test]
+  fn image_inputs_with_abort_returns_error() {
+    let tokens = vec![];
+    let request = GenerateImageRequest {
+      image_inputs: Some(ImageListRef::MediaFileTokens(&tokens)),
+      generation_mode_mismatch_strategy: Some(GenerationModeMismatchStrategy::AbortGeneration),
+      ..base_flux_pro_1p1_ultra_image_request()
+    };
+    let result = request.build();
+    assert!(matches!(
+      result,
+      Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption { field: "image_inputs", .. }))
+    ));
+  }
+
+  #[test]
+  fn image_inputs_with_generate_anyway_succeeds() {
+    let tokens = vec![];
+    let request = GenerateImageRequest {
+      image_inputs: Some(ImageListRef::MediaFileTokens(&tokens)),
+      generation_mode_mismatch_strategy: Some(GenerationModeMismatchStrategy::GenerateAnyway),
+      ..base_flux_pro_1p1_ultra_image_request()
+    };
+    assert!(request.build().is_ok());
+  }
+
+  #[test]
+  fn image_inputs_with_none_strategy_succeeds() {
+    let tokens = vec![];
+    let request = GenerateImageRequest {
+      image_inputs: Some(ImageListRef::MediaFileTokens(&tokens)),
+      generation_mode_mismatch_strategy: None,
+      ..base_flux_pro_1p1_ultra_image_request()
+    };
+    assert!(request.build().is_ok());
+  }
+
+  // ── Aspect ratio ─────────────────────────────────────────────────────────
+
+  #[test]
+  fn aspect_ratio_none_is_none() {
+    let request = GenerateImageRequest { aspect_ratio: None, ..base_flux_pro_1p1_ultra_image_request() };
+    let ImageGenerationPlan::ArtcraftFluxPro11Ultra(plan) = request.build().unwrap() else { panic!("expected ArtcraftFluxPro11Ultra") };
+    assert!(plan.aspect_ratio.is_none());
+  }
+
+  #[test]
+  fn aspect_ratio_auto_and_square_hd_fall_back_to_square() {
+    for ar in [
+      CommonAspectRatio::Auto,
+      CommonAspectRatio::Auto2k,
+      CommonAspectRatio::Auto4k,
+      CommonAspectRatio::SquareHd,
+    ] {
+      let request = GenerateImageRequest { aspect_ratio: Some(ar), ..base_flux_pro_1p1_ultra_image_request() };
+      let ImageGenerationPlan::ArtcraftFluxPro11Ultra(plan) = request.build().unwrap() else { panic!("expected ArtcraftFluxPro11Ultra") };
+      assert!(matches!(plan.aspect_ratio, Some(FlAr::Square)), "expected Square for {:?}", ar);
+    }
+  }
+
+  #[test]
+  fn aspect_ratio_direct_mappings() {
+    let cases = [
+      (CommonAspectRatio::Square, FlAr::Square),
+      (CommonAspectRatio::WideThreeByTwo, FlAr::LandscapeThreeByTwo),
+      (CommonAspectRatio::WideFourByThree, FlAr::LandscapeFourByThree),
+      (CommonAspectRatio::WideSixteenByNine, FlAr::LandscapeSixteenByNine),
+      (CommonAspectRatio::Wide, FlAr::LandscapeSixteenByNine),
+      (CommonAspectRatio::WideTwentyOneByNine, FlAr::LandscapeTwentyOneByNine),
+      (CommonAspectRatio::TallTwoByThree, FlAr::PortraitTwoByThree),
+      (CommonAspectRatio::TallThreeByFour, FlAr::PortraitThreeByFour),
+      (CommonAspectRatio::WideFiveByFour, FlAr::PortraitThreeByFour),
+      (CommonAspectRatio::TallNineBySixteen, FlAr::PortraitNineBySixteen),
+      (CommonAspectRatio::Tall, FlAr::PortraitNineBySixteen),
+      (CommonAspectRatio::TallNineByTwentyOne, FlAr::PortraitNineByTwentyOne),
+    ];
+    for (common, expected) in cases {
+      let request = GenerateImageRequest { aspect_ratio: Some(common), ..base_flux_pro_1p1_ultra_image_request() };
+      let ImageGenerationPlan::ArtcraftFluxPro11Ultra(plan) = request.build().unwrap() else { panic!("expected ArtcraftFluxPro11Ultra") };
+      assert!(
+        matches!(plan.aspect_ratio, Some(ar) if std::mem::discriminant(&ar) == std::mem::discriminant(&expected)),
+        "expected {:?} for {:?}", expected, common,
+      );
+    }
+  }
+
+  #[test]
+  fn aspect_ratio_unsupported_error_out() {
+    let request = GenerateImageRequest {
+      aspect_ratio: Some(CommonAspectRatio::TallFourByFive),
+      request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+      ..base_flux_pro_1p1_ultra_image_request()
+    };
+    assert!(matches!(
+      request.build(),
+      Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption { .. }))
+    ));
+  }
+
+  #[test]
+  fn aspect_ratio_unsupported_nearest_match() {
+    for strategy in [
+      RequestMismatchMitigationStrategy::PayMoreUpgrade,
+      RequestMismatchMitigationStrategy::PayLessDowngrade,
+    ] {
+      let request = GenerateImageRequest {
+        aspect_ratio: Some(CommonAspectRatio::TallFourByFive),
+        request_mismatch_mitigation_strategy: strategy,
+        ..base_flux_pro_1p1_ultra_image_request()
+      };
+      let ImageGenerationPlan::ArtcraftFluxPro11Ultra(plan) = request.build().unwrap() else { panic!("expected ArtcraftFluxPro11Ultra") };
+      assert!(matches!(plan.aspect_ratio, Some(FlAr::LandscapeFourByThree)));
+    }
+  }
+
+  // ── Num images ───────────────────────────────────────────────────────────
+
+  #[test]
+  fn num_images_zero_is_always_error() {
+    for strategy in [
+      RequestMismatchMitigationStrategy::ErrorOut,
+      RequestMismatchMitigationStrategy::PayMoreUpgrade,
+      RequestMismatchMitigationStrategy::PayLessDowngrade,
+    ] {
+      let request = GenerateImageRequest {
+        image_batch_count: Some(0),
+        request_mismatch_mitigation_strategy: strategy,
+        ..base_flux_pro_1p1_ultra_image_request()
+      };
+      assert!(matches!(
+        request.build(),
+        Err(ArtcraftRouterError::Client(ClientError::UserRequestedZeroGenerations))
+      ));
+    }
+  }
+
+  #[test]
+  fn num_images_direct_mapping() {
+    let cases = [(1, FlN::One), (2, FlN::Two), (3, FlN::Three), (4, FlN::Four)];
+    for (count, expected) in cases {
+      let request = GenerateImageRequest { image_batch_count: Some(count), ..base_flux_pro_1p1_ultra_image_request() };
+      let ImageGenerationPlan::ArtcraftFluxPro11Ultra(plan) = request.build().unwrap() else { panic!("expected ArtcraftFluxPro11Ultra") };
+      assert!(
+        std::mem::discriminant(&plan.num_images) == std::mem::discriminant(&expected),
+        "expected {:?} for count {}", expected, count,
+      );
+    }
+  }
+
+  #[test]
+  fn num_images_out_of_range_error_out() {
+    let request = GenerateImageRequest {
+      image_batch_count: Some(5),
+      request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+      ..base_flux_pro_1p1_ultra_image_request()
+    };
+    assert!(matches!(
+      request.build(),
+      Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption { .. }))
+    ));
+  }
+
+  #[test]
+  fn num_images_out_of_range_clamps_to_four() {
+    for strategy in [
+      RequestMismatchMitigationStrategy::PayMoreUpgrade,
+      RequestMismatchMitigationStrategy::PayLessDowngrade,
+    ] {
+      let request = GenerateImageRequest {
+        image_batch_count: Some(5),
+        request_mismatch_mitigation_strategy: strategy,
+        ..base_flux_pro_1p1_ultra_image_request()
+      };
+      let ImageGenerationPlan::ArtcraftFluxPro11Ultra(plan) = request.build().unwrap() else { panic!("expected ArtcraftFluxPro11Ultra") };
+      assert!(matches!(plan.num_images, FlN::Four));
+    }
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/plan/artcraft/plan_generate_image_artcraft_gpt_image_1p5.rs

@@ -0,0 +1,310 @@
+use crate::api::common_aspect_ratio::CommonAspectRatio;
+use crate::api::image_list_ref::ImageListRef;
+use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+use crate::errors::artcraft_router_error::ArtcraftRouterError;
+use crate::errors::client_error::ClientError;
+use crate::generate::generate_image::generate_image_request::GenerateImageRequest;
+use artcraft_api_defs::generate::image::multi_function::gpt_image_1p5_multi_function_image_gen::{
+  GptImage1p5MultiFunctionImageGenNumImages, GptImage1p5MultiFunctionImageGenQuality,
+  GptImage1p5MultiFunctionImageGenSize,
+};
+use tokens::tokens::media_files::MediaFileToken;
+
+#[derive(Debug, Clone)]
+pub struct PlanArtcraftGptImage1p5<'a> {
+  pub prompt: Option<&'a str>,
+  /// Input images for image editing. None means text-to-image mode.
+  pub image_inputs: Option<&'a Vec<MediaFileToken>>,
+  pub image_size: Option<GptImage1p5MultiFunctionImageGenSize>,
+  /// Quality defaults to Medium when not specified in the request.
+  pub quality: GptImage1p5MultiFunctionImageGenQuality,
+  pub num_images: GptImage1p5MultiFunctionImageGenNumImages,
+  pub idempotency_token: String,
+}
+
+pub fn plan_generate_image_artcraft_gpt_image_1p5<'a>(
+  request: &'a GenerateImageRequest<'a>,
+) -> Result<PlanArtcraftGptImage1p5<'a>, ArtcraftRouterError> {
+  let strategy = request.request_mismatch_mitigation_strategy;
+
+  let image_inputs = resolve_image_list_ref(request.image_inputs)?;
+  let image_size = plan_image_size(request.aspect_ratio, strategy)?;
+  let num_images = plan_num_images(request.image_batch_count, strategy)?;
+
+  Ok(PlanArtcraftGptImage1p5 {
+    prompt: request.prompt,
+    image_inputs,
+    image_size,
+    quality: GptImage1p5MultiFunctionImageGenQuality::Medium,
+    num_images,
+    idempotency_token: request.get_or_generate_idempotency_token(),
+  })
+}
+
+fn resolve_image_list_ref<'a>(
+  image_list_ref: Option<ImageListRef<'a>>,
+) -> Result<Option<&'a Vec<MediaFileToken>>, ArtcraftRouterError> {
+  match image_list_ref {
+    None => Ok(None),
+    Some(ImageListRef::MediaFileTokens(tokens)) => Ok(Some(tokens)),
+    Some(ImageListRef::Urls(_)) => {
+      Err(ArtcraftRouterError::Client(ClientError::ArtcraftOnlySupportsMediaTokens))
+    }
+  }
+}
+
+// GPT Image 1.5 image sizes: Square (1024x1024), Wide (1536x1024), Tall (1024x1536).
+// All 17 CommonAspectRatio variants map to one of these three sizes or None.
+// Auto aspect ratios yield None (let the API choose its default).
+fn plan_image_size(
+  aspect_ratio: Option<CommonAspectRatio>,
+  _strategy: RequestMismatchMitigationStrategy,
+) -> Result<Option<GptImage1p5MultiFunctionImageGenSize>, ArtcraftRouterError> {
+  use GptImage1p5MultiFunctionImageGenSize as GS;
+  match aspect_ratio {
+    // No preference or auto — let the model use its default
+    None
+    | Some(CommonAspectRatio::Auto)
+    | Some(CommonAspectRatio::Auto2k)
+    | Some(CommonAspectRatio::Auto4k) => Ok(None),
+
+    // Square
+    Some(CommonAspectRatio::Square) | Some(CommonAspectRatio::SquareHd) => Ok(Some(GS::Square)),
+
+    // Wide
+    Some(CommonAspectRatio::WideThreeByTwo)
+    | Some(CommonAspectRatio::WideFourByThree)
+    | Some(CommonAspectRatio::WideFiveByFour)
+    | Some(CommonAspectRatio::WideSixteenByNine)
+    | Some(CommonAspectRatio::WideTwentyOneByNine)
+    | Some(CommonAspectRatio::Wide) => Ok(Some(GS::Wide)),
+
+    // Tall
+    Some(CommonAspectRatio::TallTwoByThree)
+    | Some(CommonAspectRatio::TallThreeByFour)
+    | Some(CommonAspectRatio::TallFourByFive)
+    | Some(CommonAspectRatio::TallNineBySixteen)
+    | Some(CommonAspectRatio::TallNineByTwentyOne)
+    | Some(CommonAspectRatio::Tall) => Ok(Some(GS::Tall)),
+  }
+}
+
+// GPT Image 1.5 supports 1, 2, 3, and 4 images.
+
+fn plan_num_images(
+  image_batch_count: Option<u16>,
+  strategy: RequestMismatchMitigationStrategy,
+) -> Result<GptImage1p5MultiFunctionImageGenNumImages, ArtcraftRouterError> {
+  use GptImage1p5MultiFunctionImageGenNumImages as GN;
+  let count = image_batch_count.unwrap_or(1);
+  match count {
+    0 => Err(ArtcraftRouterError::Client(ClientError::UserRequestedZeroGenerations)),
+    1 => Ok(GN::One),
+    2 => Ok(GN::Two),
+    3 => Ok(GN::Three),
+    4 => Ok(GN::Four),
+    _ => match strategy {
+      RequestMismatchMitigationStrategy::ErrorOut => {
+        Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+          field: "image_batch_count",
+          value: format!("{}", count),
+        }))
+      }
+      RequestMismatchMitigationStrategy::PayMoreUpgrade => Ok(GN::Four),
+      RequestMismatchMitigationStrategy::PayLessDowngrade => Ok(GN::Four),
+    },
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+  use crate::api::common_aspect_ratio::CommonAspectRatio;
+  use crate::api::image_list_ref::ImageListRef;
+  use crate::errors::artcraft_router_error::ArtcraftRouterError;
+  use crate::errors::client_error::ClientError;
+  use crate::generate::generate_image::image_generation_plan::ImageGenerationPlan;
+  use crate::test_helpers::base_gpt_image_1p5_image_request;
+  use artcraft_api_defs::generate::image::multi_function::gpt_image_1p5_multi_function_image_gen::{
+    GptImage1p5MultiFunctionImageGenNumImages as GN,
+    GptImage1p5MultiFunctionImageGenQuality,
+    GptImage1p5MultiFunctionImageGenSize as GS,
+  };
+
+  // ── Image size (aspect ratio mapping) ────────────────────────────────────
+
+  #[test]
+  fn image_size_none_is_none() {
+    let request = GenerateImageRequest { aspect_ratio: None, ..base_gpt_image_1p5_image_request() };
+    let ImageGenerationPlan::ArtcraftGptImage1p5(plan) = request.build().unwrap() else { panic!("expected ArtcraftGptImage1p5") };
+    assert!(plan.image_size.is_none());
+  }
+
+  #[test]
+  fn image_size_auto_variants_yield_none() {
+    for auto_ar in [CommonAspectRatio::Auto, CommonAspectRatio::Auto2k, CommonAspectRatio::Auto4k] {
+      let request = GenerateImageRequest { aspect_ratio: Some(auto_ar), ..base_gpt_image_1p5_image_request() };
+      let ImageGenerationPlan::ArtcraftGptImage1p5(plan) = request.build().unwrap() else { panic!("expected ArtcraftGptImage1p5") };
+      assert!(plan.image_size.is_none(), "expected None for {:?}", auto_ar);
+    }
+  }
+
+  #[test]
+  fn image_size_square_variants() {
+    for ar in [CommonAspectRatio::Square, CommonAspectRatio::SquareHd] {
+      let request = GenerateImageRequest { aspect_ratio: Some(ar), ..base_gpt_image_1p5_image_request() };
+      let ImageGenerationPlan::ArtcraftGptImage1p5(plan) = request.build().unwrap() else { panic!("expected ArtcraftGptImage1p5") };
+      assert!(matches!(plan.image_size, Some(GS::Square)), "expected Square for {:?}", ar);
+    }
+  }
+
+  #[test]
+  fn image_size_wide_variants() {
+    let wide_ars = [
+      CommonAspectRatio::WideThreeByTwo,
+      CommonAspectRatio::WideFourByThree,
+      CommonAspectRatio::WideFiveByFour,
+      CommonAspectRatio::WideSixteenByNine,
+      CommonAspectRatio::WideTwentyOneByNine,
+      CommonAspectRatio::Wide,
+    ];
+    for ar in wide_ars {
+      let request = GenerateImageRequest { aspect_ratio: Some(ar), ..base_gpt_image_1p5_image_request() };
+      let ImageGenerationPlan::ArtcraftGptImage1p5(plan) = request.build().unwrap() else { panic!("expected ArtcraftGptImage1p5") };
+      assert!(matches!(plan.image_size, Some(GS::Wide)), "expected Wide for {:?}", ar);
+    }
+  }
+
+  #[test]
+  fn image_size_tall_variants() {
+    let tall_ars = [
+      CommonAspectRatio::TallTwoByThree,
+      CommonAspectRatio::TallThreeByFour,
+      CommonAspectRatio::TallFourByFive,
+      CommonAspectRatio::TallNineBySixteen,
+      CommonAspectRatio::TallNineByTwentyOne,
+      CommonAspectRatio::Tall,
+    ];
+    for ar in tall_ars {
+      let request = GenerateImageRequest { aspect_ratio: Some(ar), ..base_gpt_image_1p5_image_request() };
+      let ImageGenerationPlan::ArtcraftGptImage1p5(plan) = request.build().unwrap() else { panic!("expected ArtcraftGptImage1p5") };
+      assert!(matches!(plan.image_size, Some(GS::Tall)), "expected Tall for {:?}", ar);
+    }
+  }
+
+  // ── Quality ──────────────────────────────────────────────────────────────
+
+  #[test]
+  fn quality_defaults_to_medium() {
+    let request = base_gpt_image_1p5_image_request();
+    let ImageGenerationPlan::ArtcraftGptImage1p5(plan) = request.build().unwrap() else { panic!("expected ArtcraftGptImage1p5") };
+    assert!(matches!(plan.quality, GptImage1p5MultiFunctionImageGenQuality::Medium));
+  }
+
+  // ── Num images ──────────────────────────────────────────────────────────────
+
+  #[test]
+  fn num_images_zero_is_always_error() {
+    for strategy in [
+      RequestMismatchMitigationStrategy::ErrorOut,
+      RequestMismatchMitigationStrategy::PayMoreUpgrade,
+      RequestMismatchMitigationStrategy::PayLessDowngrade,
+    ] {
+      let request = GenerateImageRequest {
+        image_batch_count: Some(0),
+        request_mismatch_mitigation_strategy: strategy,
+        ..base_gpt_image_1p5_image_request()
+      };
+      let result = request.build();
+      assert!(
+        matches!(result, Err(ArtcraftRouterError::Client(ClientError::UserRequestedZeroGenerations))),
+        "expected UserRequestedZeroGenerations with {:?}", strategy,
+      );
+    }
+  }
+
+  #[test]
+  fn num_images_direct_mapping() {
+    let cases = [
+      (1, GN::One),
+      (2, GN::Two),
+      (3, GN::Three),
+      (4, GN::Four),
+    ];
+    for (count, expected) in cases {
+      let request = GenerateImageRequest { image_batch_count: Some(count), ..base_gpt_image_1p5_image_request() };
+      let ImageGenerationPlan::ArtcraftGptImage1p5(plan) = request.build().unwrap() else { panic!("expected ArtcraftGptImage1p5") };
+      assert!(
+        std::mem::discriminant(&plan.num_images) == std::mem::discriminant(&expected),
+        "expected {:?} for count {}", expected, count,
+      );
+    }
+  }
+
+  #[test]
+  fn num_images_out_of_range_error_out() {
+    let request = GenerateImageRequest {
+      image_batch_count: Some(5),
+      request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+      ..base_gpt_image_1p5_image_request()
+    };
+    let result = request.build();
+    assert!(matches!(
+      result,
+      Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption { .. }))
+    ));
+  }
+
+  #[test]
+  fn num_images_out_of_range_clamps_to_four() {
+    for strategy in [
+      RequestMismatchMitigationStrategy::PayMoreUpgrade,
+      RequestMismatchMitigationStrategy::PayLessDowngrade,
+    ] {
+      let request = GenerateImageRequest {
+        image_batch_count: Some(5),
+        request_mismatch_mitigation_strategy: strategy,
+        ..base_gpt_image_1p5_image_request()
+      };
+      let ImageGenerationPlan::ArtcraftGptImage1p5(plan) = request.build().unwrap() else { panic!("expected ArtcraftGptImage1p5") };
+      assert!(
+        matches!(plan.num_images, GN::Four),
+        "expected Four for count 5 with {:?}", strategy,
+      );
+    }
+  }
+
+  // ── Image inputs ─────────────────────────────────────────────────────────
+
+  #[test]
+  fn url_image_inputs_returns_error() {
+    let urls = vec!["https://example.com/image.jpg".to_string()];
+    let request = GenerateImageRequest {
+      image_inputs: Some(ImageListRef::Urls(&urls)),
+      ..base_gpt_image_1p5_image_request()
+    };
+    let result = request.build();
+    assert!(matches!(
+      result,
+      Err(ArtcraftRouterError::Client(ClientError::ArtcraftOnlySupportsMediaTokens))
+    ));
+  }
+
+  #[test]
+  fn no_image_inputs_is_text_to_image_mode() {
+    let request = GenerateImageRequest { image_inputs: None, ..base_gpt_image_1p5_image_request() };
+    let ImageGenerationPlan::ArtcraftGptImage1p5(plan) = request.build().unwrap() else { panic!("expected ArtcraftGptImage1p5") };
+    assert!(plan.image_inputs.is_none());
+  }
+
+  #[test]
+  fn media_token_image_inputs_is_edit_mode() {
+    let tokens = vec![];
+    let request = GenerateImageRequest {
+      image_inputs: Some(ImageListRef::MediaFileTokens(&tokens)),
+      ..base_gpt_image_1p5_image_request()
+    };
+    let ImageGenerationPlan::ArtcraftGptImage1p5(plan) = request.build().unwrap() else { panic!("expected ArtcraftGptImage1p5") };
+    assert!(plan.image_inputs.is_some());
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/plan/artcraft/plan_generate_image_artcraft_nano_banana.rs

@@ -0,0 +1,389 @@
+use crate::api::common_aspect_ratio::CommonAspectRatio;
+use crate::api::image_list_ref::ImageListRef;
+use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+use crate::errors::artcraft_router_error::ArtcraftRouterError;
+use crate::errors::client_error::ClientError;
+use crate::generate::generate_image::generate_image_request::GenerateImageRequest;
+use artcraft_api_defs::generate::image::multi_function::nano_banana_multi_function_image_gen::{
+  NanoBananaMultiFunctionImageGenAspectRatio, NanoBananaMultiFunctionImageGenNumImages,
+};
+use tokens::tokens::media_files::MediaFileToken;
+
+#[derive(Debug, Clone)]
+pub struct PlanArtcraftNanaBanana<'a> {
+  pub prompt: Option<&'a str>,
+  /// Input images for image editing. None means text-to-image mode.
+  pub image_inputs: Option<&'a Vec<MediaFileToken>>,
+  pub aspect_ratio: Option<NanoBananaMultiFunctionImageGenAspectRatio>,
+  pub num_images: NanoBananaMultiFunctionImageGenNumImages,
+  pub idempotency_token: String,
+}
+
+pub fn plan_generate_image_artcraft_nano_banana<'a>(
+  request: &'a GenerateImageRequest<'a>,
+) -> Result<PlanArtcraftNanaBanana<'a>, ArtcraftRouterError> {
+  let strategy = request.request_mismatch_mitigation_strategy;
+
+  let is_edit_mode = request.image_inputs.is_some();
+  let image_inputs = resolve_image_list_ref(request.image_inputs)?;
+  let aspect_ratio = plan_aspect_ratio(request.aspect_ratio, is_edit_mode, strategy)?;
+  let num_images = plan_num_images(request.image_batch_count, strategy)?;
+
+  Ok(PlanArtcraftNanaBanana {
+    prompt: request.prompt,
+    image_inputs,
+    aspect_ratio,
+    num_images,
+    idempotency_token: request.get_or_generate_idempotency_token(),
+  })
+}
+
+fn resolve_image_list_ref<'a>(
+  image_list_ref: Option<ImageListRef<'a>>,
+) -> Result<Option<&'a Vec<MediaFileToken>>, ArtcraftRouterError> {
+  match image_list_ref {
+    None => Ok(None),
+    Some(ImageListRef::MediaFileTokens(tokens)) => Ok(Some(tokens)),
+    Some(ImageListRef::Urls(_)) => {
+      Err(ArtcraftRouterError::Client(ClientError::ArtcraftOnlySupportsMediaTokens))
+    }
+  }
+}
+
+// Nano Banana supported aspect ratios:
+//   Text-to-image: OneByOne, FiveByFour, FourByThree, ThreeByTwo, SixteenByNine, TwentyOneByNine,
+//                  FourByFive, ThreeByFour, TwoByThree, NineBySixteen
+//   Image editing: Auto (uses source image AR), plus all text-to-image ratios
+fn plan_aspect_ratio(
+  aspect_ratio: Option<CommonAspectRatio>,
+  is_edit_mode: bool,
+  strategy: RequestMismatchMitigationStrategy,
+) -> Result<Option<NanoBananaMultiFunctionImageGenAspectRatio>, ArtcraftRouterError> {
+  use NanoBananaMultiFunctionImageGenAspectRatio as NbAr;
+  match aspect_ratio {
+    // No preference — let the model use its default
+    None => Ok(None),
+
+    // Auto: only valid in edit mode (use source image dimensions)
+    Some(CommonAspectRatio::Auto)
+    | Some(CommonAspectRatio::Auto2k)
+    | Some(CommonAspectRatio::Auto4k) => {
+      if is_edit_mode {
+        Ok(Some(NbAr::Auto))
+      } else {
+        // Auto not valid for text-to-image; fall back to square default
+        Ok(Some(NbAr::OneByOne))
+      }
+    }
+
+    // Direct mappings
+    Some(CommonAspectRatio::Square) | Some(CommonAspectRatio::SquareHd) => Ok(Some(NbAr::OneByOne)),
+    Some(CommonAspectRatio::WideFiveByFour) => Ok(Some(NbAr::FiveByFour)),
+    Some(CommonAspectRatio::WideFourByThree) => Ok(Some(NbAr::FourByThree)),
+    Some(CommonAspectRatio::WideThreeByTwo) => Ok(Some(NbAr::ThreeByTwo)),
+    Some(CommonAspectRatio::WideSixteenByNine) | Some(CommonAspectRatio::Wide) => Ok(Some(NbAr::SixteenByNine)),
+    Some(CommonAspectRatio::WideTwentyOneByNine) => Ok(Some(NbAr::TwentyOneByNine)),
+    Some(CommonAspectRatio::TallFourByFive) => Ok(Some(NbAr::FourByFive)),
+    Some(CommonAspectRatio::TallThreeByFour) => Ok(Some(NbAr::ThreeByFour)),
+    Some(CommonAspectRatio::TallTwoByThree) => Ok(Some(NbAr::TwoByThree)),
+    Some(CommonAspectRatio::TallNineBySixteen) | Some(CommonAspectRatio::Tall) => Ok(Some(NbAr::NineBySixteen)),
+
+    // Mismatch — TallNineByTwentyOne has no direct equivalent
+    Some(unsupported) => match strategy {
+      RequestMismatchMitigationStrategy::ErrorOut => {
+        Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+          field: "aspect_ratio",
+          value: format!("{:?}", unsupported),
+        }))
+      }
+      RequestMismatchMitigationStrategy::PayMoreUpgrade
+      | RequestMismatchMitigationStrategy::PayLessDowngrade => {
+        Ok(Some(nearest_aspect_ratio(unsupported)))
+      }
+    },
+  }
+}
+
+/// Pick the nearest supported aspect ratio for unsupported inputs.
+fn nearest_aspect_ratio(aspect_ratio: CommonAspectRatio) -> NanoBananaMultiFunctionImageGenAspectRatio {
+  use NanoBananaMultiFunctionImageGenAspectRatio as NbAr;
+  match aspect_ratio {
+    // TallNineByTwentyOne (0.43) — nearest is NineBySixteen (0.5625)
+    CommonAspectRatio::TallNineByTwentyOne => NbAr::NineBySixteen,
+    _ => NbAr::OneByOne,
+  }
+}
+
+// Nano Banana supports 1, 2, 3, and 4 images.
+
+fn plan_num_images(
+  image_batch_count: Option<u16>,
+  strategy: RequestMismatchMitigationStrategy,
+) -> Result<NanoBananaMultiFunctionImageGenNumImages, ArtcraftRouterError> {
+  use NanoBananaMultiFunctionImageGenNumImages as NbN;
+  let count = image_batch_count.unwrap_or(1);
+  match count {
+    0 => Err(ArtcraftRouterError::Client(ClientError::UserRequestedZeroGenerations)),
+    1 => Ok(NbN::One),
+    2 => Ok(NbN::Two),
+    3 => Ok(NbN::Three),
+    4 => Ok(NbN::Four),
+    _ => match strategy {
+      RequestMismatchMitigationStrategy::ErrorOut => {
+        Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+          field: "image_batch_count",
+          value: format!("{}", count),
+        }))
+      }
+      RequestMismatchMitigationStrategy::PayMoreUpgrade => Ok(NbN::Four),
+      RequestMismatchMitigationStrategy::PayLessDowngrade => Ok(NbN::Four),
+    },
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+  use crate::api::common_aspect_ratio::CommonAspectRatio;
+  use crate::api::image_list_ref::ImageListRef;
+  use crate::errors::artcraft_router_error::ArtcraftRouterError;
+  use crate::errors::client_error::ClientError;
+  use crate::generate::generate_image::image_generation_plan::ImageGenerationPlan;
+  use crate::test_helpers::base_nano_banana_image_request;
+  use artcraft_api_defs::generate::image::multi_function::nano_banana_multi_function_image_gen::{
+    NanoBananaMultiFunctionImageGenAspectRatio as NbAr,
+    NanoBananaMultiFunctionImageGenNumImages as NbN,
+  };
+
+  // ── Aspect ratio ────────────────────────────────────────────────────────────
+
+  #[test]
+  fn aspect_ratio_none_is_none() {
+    let request = GenerateImageRequest { aspect_ratio: None, ..base_nano_banana_image_request() };
+    let ImageGenerationPlan::ArtcraftNanaBanana(plan) = request.build().unwrap() else { panic!("expected ArtcraftNanaBanana") };
+    assert!(plan.aspect_ratio.is_none());
+  }
+
+  #[test]
+  fn aspect_ratio_direct_square() {
+    for ar in [CommonAspectRatio::Square, CommonAspectRatio::SquareHd] {
+      let request = GenerateImageRequest { aspect_ratio: Some(ar), ..base_nano_banana_image_request() };
+      let ImageGenerationPlan::ArtcraftNanaBanana(plan) = request.build().unwrap() else { panic!("expected ArtcraftNanaBanana") };
+      assert!(matches!(plan.aspect_ratio, Some(NbAr::OneByOne)), "expected OneByOne for {:?}", ar);
+    }
+  }
+
+  #[test]
+  fn aspect_ratio_direct_wide() {
+    let cases = [
+      (CommonAspectRatio::WideFiveByFour, NbAr::FiveByFour),
+      (CommonAspectRatio::WideFourByThree, NbAr::FourByThree),
+      (CommonAspectRatio::WideThreeByTwo, NbAr::ThreeByTwo),
+      (CommonAspectRatio::WideSixteenByNine, NbAr::SixteenByNine),
+      (CommonAspectRatio::Wide, NbAr::SixteenByNine),
+      (CommonAspectRatio::WideTwentyOneByNine, NbAr::TwentyOneByNine),
+    ];
+    for (common, expected) in cases {
+      let request = GenerateImageRequest { aspect_ratio: Some(common), ..base_nano_banana_image_request() };
+      let ImageGenerationPlan::ArtcraftNanaBanana(plan) = request.build().unwrap() else { panic!("expected ArtcraftNanaBanana") };
+      assert!(
+        matches!(plan.aspect_ratio, Some(ar) if std::mem::discriminant(&ar) == std::mem::discriminant(&expected)),
+        "expected {:?} for {:?}", expected, common,
+      );
+    }
+  }
+
+  #[test]
+  fn aspect_ratio_direct_tall() {
+    let cases = [
+      (CommonAspectRatio::TallFourByFive, NbAr::FourByFive),
+      (CommonAspectRatio::TallThreeByFour, NbAr::ThreeByFour),
+      (CommonAspectRatio::TallTwoByThree, NbAr::TwoByThree),
+      (CommonAspectRatio::TallNineBySixteen, NbAr::NineBySixteen),
+      (CommonAspectRatio::Tall, NbAr::NineBySixteen),
+    ];
+    for (common, expected) in cases {
+      let request = GenerateImageRequest { aspect_ratio: Some(common), ..base_nano_banana_image_request() };
+      let ImageGenerationPlan::ArtcraftNanaBanana(plan) = request.build().unwrap() else { panic!("expected ArtcraftNanaBanana") };
+      assert!(
+        matches!(plan.aspect_ratio, Some(ar) if std::mem::discriminant(&ar) == std::mem::discriminant(&expected)),
+        "expected {:?} for {:?}", expected, common,
+      );
+    }
+  }
+
+  #[test]
+  fn aspect_ratio_auto_in_edit_mode_yields_auto() {
+    for auto_ar in [CommonAspectRatio::Auto, CommonAspectRatio::Auto2k, CommonAspectRatio::Auto4k] {
+      let tokens = vec![];
+      let request = GenerateImageRequest {
+        aspect_ratio: Some(auto_ar),
+        image_inputs: Some(ImageListRef::MediaFileTokens(&tokens)),
+        ..base_nano_banana_image_request()
+      };
+      let ImageGenerationPlan::ArtcraftNanaBanana(plan) = request.build().unwrap() else { panic!("expected ArtcraftNanaBanana") };
+      assert!(
+        matches!(plan.aspect_ratio, Some(NbAr::Auto)),
+        "expected Auto in edit mode for {:?}", auto_ar,
+      );
+    }
+  }
+
+  #[test]
+  fn aspect_ratio_auto_in_text_to_image_mode_falls_back_to_square() {
+    for auto_ar in [CommonAspectRatio::Auto, CommonAspectRatio::Auto2k, CommonAspectRatio::Auto4k] {
+      let request = GenerateImageRequest {
+        aspect_ratio: Some(auto_ar),
+        image_inputs: None,
+        ..base_nano_banana_image_request()
+      };
+      let ImageGenerationPlan::ArtcraftNanaBanana(plan) = request.build().unwrap() else { panic!("expected ArtcraftNanaBanana") };
+      assert!(
+        matches!(plan.aspect_ratio, Some(NbAr::OneByOne)),
+        "expected OneByOne fallback in text-to-image for {:?}", auto_ar,
+      );
+    }
+  }
+
+  #[test]
+  fn aspect_ratio_unsupported_error_out() {
+    // TallNineByTwentyOne has no direct equivalent
+    let request = GenerateImageRequest {
+      aspect_ratio: Some(CommonAspectRatio::TallNineByTwentyOne),
+      request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+      ..base_nano_banana_image_request()
+    };
+    let result = request.build();
+    assert!(matches!(
+      result,
+      Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption { .. }))
+    ));
+  }
+
+  #[test]
+  fn aspect_ratio_unsupported_nearest_match() {
+    // TallNineByTwentyOne (0.43) is nearest to NineBySixteen (0.5625)
+    for strategy in [
+      RequestMismatchMitigationStrategy::PayMoreUpgrade,
+      RequestMismatchMitigationStrategy::PayLessDowngrade,
+    ] {
+      let request = GenerateImageRequest {
+        aspect_ratio: Some(CommonAspectRatio::TallNineByTwentyOne),
+        request_mismatch_mitigation_strategy: strategy,
+        ..base_nano_banana_image_request()
+      };
+      let ImageGenerationPlan::ArtcraftNanaBanana(plan) = request.build().unwrap() else { panic!("expected ArtcraftNanaBanana") };
+      assert!(
+        matches!(plan.aspect_ratio, Some(NbAr::NineBySixteen)),
+        "expected NineBySixteen nearest match with {:?}", strategy,
+      );
+    }
+  }
+
+  // ── Num images ──────────────────────────────────────────────────────────────
+
+  #[test]
+  fn num_images_zero_is_always_error() {
+    for strategy in [
+      RequestMismatchMitigationStrategy::ErrorOut,
+      RequestMismatchMitigationStrategy::PayMoreUpgrade,
+      RequestMismatchMitigationStrategy::PayLessDowngrade,
+    ] {
+      let request = GenerateImageRequest {
+        image_batch_count: Some(0),
+        request_mismatch_mitigation_strategy: strategy,
+        ..base_nano_banana_image_request()
+      };
+      let result = request.build();
+      assert!(
+        matches!(result, Err(ArtcraftRouterError::Client(ClientError::UserRequestedZeroGenerations))),
+        "expected UserRequestedZeroGenerations with {:?}", strategy,
+      );
+    }
+  }
+
+  #[test]
+  fn num_images_direct_mapping() {
+    let cases = [
+      (1, NbN::One),
+      (2, NbN::Two),
+      (3, NbN::Three),
+      (4, NbN::Four),
+    ];
+    for (count, expected) in cases {
+      let request = GenerateImageRequest { image_batch_count: Some(count), ..base_nano_banana_image_request() };
+      let ImageGenerationPlan::ArtcraftNanaBanana(plan) = request.build().unwrap() else { panic!("expected ArtcraftNanaBanana") };
+      assert!(
+        std::mem::discriminant(&plan.num_images) == std::mem::discriminant(&expected),
+        "expected {:?} for count {}", expected, count,
+      );
+    }
+  }
+
+  #[test]
+  fn num_images_out_of_range_error_out() {
+    let request = GenerateImageRequest {
+      image_batch_count: Some(5),
+      request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+      ..base_nano_banana_image_request()
+    };
+    let result = request.build();
+    assert!(matches!(
+      result,
+      Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption { .. }))
+    ));
+  }
+
+  #[test]
+  fn num_images_out_of_range_clamps_to_four() {
+    for strategy in [
+      RequestMismatchMitigationStrategy::PayMoreUpgrade,
+      RequestMismatchMitigationStrategy::PayLessDowngrade,
+    ] {
+      let request = GenerateImageRequest {
+        image_batch_count: Some(5),
+        request_mismatch_mitigation_strategy: strategy,
+        ..base_nano_banana_image_request()
+      };
+      let ImageGenerationPlan::ArtcraftNanaBanana(plan) = request.build().unwrap() else { panic!("expected ArtcraftNanaBanana") };
+      assert!(
+        matches!(plan.num_images, NbN::Four),
+        "expected Four for count 5 with {:?}", strategy,
+      );
+    }
+  }
+
+  // ── Image inputs ─────────────────────────────────────────────────────────
+
+  #[test]
+  fn url_image_inputs_returns_error() {
+    let urls = vec!["https://example.com/image.jpg".to_string()];
+    let request = GenerateImageRequest {
+      image_inputs: Some(ImageListRef::Urls(&urls)),
+      ..base_nano_banana_image_request()
+    };
+    let result = request.build();
+    assert!(matches!(
+      result,
+      Err(ArtcraftRouterError::Client(ClientError::ArtcraftOnlySupportsMediaTokens))
+    ));
+  }
+
+  #[test]
+  fn no_image_inputs_is_text_to_image_mode() {
+    let request = GenerateImageRequest { image_inputs: None, ..base_nano_banana_image_request() };
+    let ImageGenerationPlan::ArtcraftNanaBanana(plan) = request.build().unwrap() else { panic!("expected ArtcraftNanaBanana") };
+    assert!(plan.image_inputs.is_none());
+  }
+
+  #[test]
+  fn media_token_image_inputs_is_edit_mode() {
+    let tokens = vec![];
+    let request = GenerateImageRequest {
+      image_inputs: Some(ImageListRef::MediaFileTokens(&tokens)),
+      ..base_nano_banana_image_request()
+    };
+    let ImageGenerationPlan::ArtcraftNanaBanana(plan) = request.build().unwrap() else { panic!("expected ArtcraftNanaBanana") };
+    assert!(plan.image_inputs.is_some());
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/plan/artcraft/plan_generate_image_artcraft_nano_banana_2.rs

@@ -0,0 +1,289 @@
+use crate::api::common_aspect_ratio::CommonAspectRatio;
+use crate::api::common_resolution::CommonResolution;
+use crate::api::image_list_ref::ImageListRef;
+use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+use crate::errors::artcraft_router_error::ArtcraftRouterError;
+use crate::errors::client_error::ClientError;
+use crate::generate::generate_image::generate_image_request::GenerateImageRequest;
+use artcraft_api_defs::generate::image::multi_function::nano_banana_2_multi_function_image_gen::{
+  NanaBanana2MultiFunctionImageGenAspectRatio, NanaBanana2MultiFunctionImageGenImageResolution,
+  NanaBanana2MultiFunctionImageGenNumImages,
+};
+use tokens::tokens::media_files::MediaFileToken;
+
+#[derive(Debug, Clone)]
+pub struct PlanArtcraftNanaBanana2<'a> {
+  pub prompt: Option<&'a str>,
+  /// Input images for image editing. None means text-to-image mode.
+  pub image_inputs: Option<&'a Vec<MediaFileToken>>,
+  pub aspect_ratio: Option<NanaBanana2MultiFunctionImageGenAspectRatio>,
+  pub resolution: Option<NanaBanana2MultiFunctionImageGenImageResolution>,
+  pub num_images: NanaBanana2MultiFunctionImageGenNumImages,
+  pub idempotency_token: String,
+}
+
+pub fn plan_generate_image_artcraft_nano_banana_2<'a>(
+  request: &'a GenerateImageRequest<'a>,
+) -> Result<PlanArtcraftNanaBanana2<'a>, ArtcraftRouterError> {
+  let strategy = request.request_mismatch_mitigation_strategy;
+
+  let is_edit_mode = request.image_inputs.is_some();
+  let image_inputs = resolve_image_list_ref(request.image_inputs)?;
+  let aspect_ratio = plan_aspect_ratio(request.aspect_ratio, is_edit_mode, strategy)?;
+  let resolution = plan_resolution(request.resolution, strategy)?;
+  let num_images = plan_num_images(request.image_batch_count, strategy)?;
+
+  Ok(PlanArtcraftNanaBanana2 {
+    prompt: request.prompt,
+    image_inputs,
+    aspect_ratio,
+    resolution,
+    num_images,
+    idempotency_token: request.get_or_generate_idempotency_token(),
+  })
+}
+
+fn resolve_image_list_ref<'a>(
+  image_list_ref: Option<ImageListRef<'a>>,
+) -> Result<Option<&'a Vec<MediaFileToken>>, ArtcraftRouterError> {
+  match image_list_ref {
+    None => Ok(None),
+    Some(ImageListRef::MediaFileTokens(tokens)) => Ok(Some(tokens)),
+    Some(ImageListRef::Urls(_)) => {
+      Err(ArtcraftRouterError::Client(ClientError::ArtcraftOnlySupportsMediaTokens))
+    }
+  }
+}
+
+// Nano Banana 2 supported aspect ratios:
+//   Text-to-image: OneByOne, FiveByFour, FourByThree, ThreeByTwo, SixteenByNine, TwentyOneByNine,
+//                  FourByFive, ThreeByFour, TwoByThree, NineBySixteen
+//   Image editing: Auto (uses source image AR), plus all text-to-image ratios
+fn plan_aspect_ratio(
+  aspect_ratio: Option<CommonAspectRatio>,
+  is_edit_mode: bool,
+  strategy: RequestMismatchMitigationStrategy,
+) -> Result<Option<NanaBanana2MultiFunctionImageGenAspectRatio>, ArtcraftRouterError> {
+  use NanaBanana2MultiFunctionImageGenAspectRatio as Nb2Ar;
+  match aspect_ratio {
+    // No preference — let the model use its default
+    None => Ok(None),
+
+    // Auto: only valid in edit mode (use source image dimensions)
+    Some(CommonAspectRatio::Auto)
+    | Some(CommonAspectRatio::Auto2k)
+    | Some(CommonAspectRatio::Auto4k) => {
+      if is_edit_mode {
+        Ok(Some(Nb2Ar::Auto))
+      } else {
+        // Auto not valid for text-to-image; fall back to square default
+        Ok(Some(Nb2Ar::OneByOne))
+      }
+    }
+
+    // Direct mappings
+    Some(CommonAspectRatio::Square) | Some(CommonAspectRatio::SquareHd) => Ok(Some(Nb2Ar::OneByOne)),
+    Some(CommonAspectRatio::WideFiveByFour) => Ok(Some(Nb2Ar::FiveByFour)),
+    Some(CommonAspectRatio::WideFourByThree) => Ok(Some(Nb2Ar::FourByThree)),
+    Some(CommonAspectRatio::WideThreeByTwo) => Ok(Some(Nb2Ar::ThreeByTwo)),
+    Some(CommonAspectRatio::WideSixteenByNine) | Some(CommonAspectRatio::Wide) => Ok(Some(Nb2Ar::SixteenByNine)),
+    Some(CommonAspectRatio::WideTwentyOneByNine) => Ok(Some(Nb2Ar::TwentyOneByNine)),
+    Some(CommonAspectRatio::TallFourByFive) => Ok(Some(Nb2Ar::FourByFive)),
+    Some(CommonAspectRatio::TallThreeByFour) => Ok(Some(Nb2Ar::ThreeByFour)),
+    Some(CommonAspectRatio::TallTwoByThree) => Ok(Some(Nb2Ar::TwoByThree)),
+    Some(CommonAspectRatio::TallNineBySixteen) | Some(CommonAspectRatio::Tall) => Ok(Some(Nb2Ar::NineBySixteen)),
+
+    // Mismatch — TallNineByTwentyOne has no direct equivalent
+    Some(unsupported) => match strategy {
+      RequestMismatchMitigationStrategy::ErrorOut => {
+        Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+          field: "aspect_ratio",
+          value: format!("{:?}", unsupported),
+        }))
+      }
+      RequestMismatchMitigationStrategy::PayMoreUpgrade
+      | RequestMismatchMitigationStrategy::PayLessDowngrade => {
+        Ok(Some(nearest_aspect_ratio(unsupported)))
+      }
+    },
+  }
+}
+
+/// Pick the nearest supported aspect ratio for unsupported inputs.
+fn nearest_aspect_ratio(aspect_ratio: CommonAspectRatio) -> NanaBanana2MultiFunctionImageGenAspectRatio {
+  use NanaBanana2MultiFunctionImageGenAspectRatio as Nb2Ar;
+  match aspect_ratio {
+    // TallNineByTwentyOne (0.43) — nearest is NineBySixteen (0.5625)
+    CommonAspectRatio::TallNineByTwentyOne => Nb2Ar::NineBySixteen,
+    _ => Nb2Ar::OneByOne,
+  }
+}
+
+fn plan_resolution(
+  resolution: Option<CommonResolution>,
+  _strategy: RequestMismatchMitigationStrategy,
+) -> Result<Option<NanaBanana2MultiFunctionImageGenImageResolution>, ArtcraftRouterError> {
+  use CommonResolution as R;
+  use NanaBanana2MultiFunctionImageGenImageResolution as Nb2Res;
+  match resolution {
+    None => Ok(None),
+    Some(R::OneK) => Ok(Some(Nb2Res::OneK)),
+    Some(R::TwoK) => Ok(Some(Nb2Res::TwoK)),
+    Some(R::FourK) => Ok(Some(Nb2Res::FourK)),
+    Some(R::ThreeK) => {
+      // No 3K option; default to 2K
+      Ok(Some(Nb2Res::TwoK))
+    }
+  }
+}
+
+// Nano Banana 2 supports 1, 2, 3, and 4 images.
+
+fn plan_num_images(
+  image_batch_count: Option<u16>,
+  strategy: RequestMismatchMitigationStrategy,
+) -> Result<NanaBanana2MultiFunctionImageGenNumImages, ArtcraftRouterError> {
+  use NanaBanana2MultiFunctionImageGenNumImages as Nb2N;
+  let count = image_batch_count.unwrap_or(1);
+  match count {
+    0 => Err(ArtcraftRouterError::Client(ClientError::UserRequestedZeroGenerations)),
+    1 => Ok(Nb2N::One),
+    2 => Ok(Nb2N::Two),
+    3 => Ok(Nb2N::Three),
+    4 => Ok(Nb2N::Four),
+    _ => match strategy {
+      RequestMismatchMitigationStrategy::ErrorOut => {
+        Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+          field: "image_batch_count",
+          value: format!("{}", count),
+        }))
+      }
+      RequestMismatchMitigationStrategy::PayMoreUpgrade => Ok(Nb2N::Four),
+      RequestMismatchMitigationStrategy::PayLessDowngrade => Ok(Nb2N::Four),
+    },
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+  use crate::api::common_aspect_ratio::CommonAspectRatio;
+  use crate::api::common_resolution::CommonResolution;
+  use crate::api::image_list_ref::ImageListRef;
+  use crate::errors::artcraft_router_error::ArtcraftRouterError;
+  use crate::errors::client_error::ClientError;
+  use crate::generate::generate_image::image_generation_plan::ImageGenerationPlan;
+  use crate::test_helpers::base_nano_banana_2_image_request;
+  use artcraft_api_defs::generate::image::multi_function::nano_banana_2_multi_function_image_gen::{
+    NanaBanana2MultiFunctionImageGenAspectRatio as Nb2Ar,
+    NanaBanana2MultiFunctionImageGenImageResolution as Nb2Res,
+    NanaBanana2MultiFunctionImageGenNumImages as Nb2N,
+  };
+
+  // ── Aspect ratio ────────────────────────────────────────────────────────────
+
+  #[test]
+  fn aspect_ratio_none_is_none() {
+    let request = GenerateImageRequest { aspect_ratio: None, ..base_nano_banana_2_image_request() };
+    let ImageGenerationPlan::ArtcraftNanaBanana2(plan) = request.build().unwrap() else { panic!("expected ArtcraftNanaBanana2") };
+    assert!(plan.aspect_ratio.is_none());
+  }
+
+  #[test]
+  fn aspect_ratio_direct_square() {
+    for ar in [CommonAspectRatio::Square, CommonAspectRatio::SquareHd] {
+      let request = GenerateImageRequest { aspect_ratio: Some(ar), ..base_nano_banana_2_image_request() };
+      let ImageGenerationPlan::ArtcraftNanaBanana2(plan) = request.build().unwrap() else { panic!("expected ArtcraftNanaBanana2") };
+      assert!(matches!(plan.aspect_ratio, Some(Nb2Ar::OneByOne)), "expected OneByOne for {:?}", ar);
+    }
+  }
+
+  #[test]
+  fn aspect_ratio_auto_in_edit_mode_yields_auto() {
+    for auto_ar in [CommonAspectRatio::Auto, CommonAspectRatio::Auto2k, CommonAspectRatio::Auto4k] {
+      let tokens = vec![];
+      let request = GenerateImageRequest {
+        aspect_ratio: Some(auto_ar),
+        image_inputs: Some(ImageListRef::MediaFileTokens(&tokens)),
+        ..base_nano_banana_2_image_request()
+      };
+      let ImageGenerationPlan::ArtcraftNanaBanana2(plan) = request.build().unwrap() else { panic!("expected ArtcraftNanaBanana2") };
+      assert!(
+        matches!(plan.aspect_ratio, Some(Nb2Ar::Auto)),
+        "expected Auto in edit mode for {:?}", auto_ar,
+      );
+    }
+  }
+
+  #[test]
+  fn aspect_ratio_auto_in_text_to_image_falls_back_to_square() {
+    for auto_ar in [CommonAspectRatio::Auto, CommonAspectRatio::Auto2k, CommonAspectRatio::Auto4k] {
+      let request = GenerateImageRequest {
+        aspect_ratio: Some(auto_ar),
+        image_inputs: None,
+        ..base_nano_banana_2_image_request()
+      };
+      let ImageGenerationPlan::ArtcraftNanaBanana2(plan) = request.build().unwrap() else { panic!("expected ArtcraftNanaBanana2") };
+      assert!(
+        matches!(plan.aspect_ratio, Some(Nb2Ar::OneByOne)),
+        "expected OneByOne fallback in text-to-image for {:?}", auto_ar,
+      );
+    }
+  }
+
+  // ── Resolution ──────────────────────────────────────────────────────────────
+
+  #[test]
+  fn resolution_none_is_none() {
+    let request = GenerateImageRequest { resolution: None, ..base_nano_banana_2_image_request() };
+    let ImageGenerationPlan::ArtcraftNanaBanana2(plan) = request.build().unwrap() else { panic!("expected ArtcraftNanaBanana2") };
+    assert!(plan.resolution.is_none());
+  }
+
+  #[test]
+  fn resolution_direct_mappings() {
+    let cases = [
+      (CommonResolution::OneK, Nb2Res::OneK),
+      (CommonResolution::TwoK, Nb2Res::TwoK),
+      (CommonResolution::FourK, Nb2Res::FourK),
+    ];
+    for (common, expected) in cases {
+      let request = GenerateImageRequest { resolution: Some(common), ..base_nano_banana_2_image_request() };
+      let ImageGenerationPlan::ArtcraftNanaBanana2(plan) = request.build().unwrap() else { panic!("expected ArtcraftNanaBanana2") };
+      assert!(
+        matches!(plan.resolution, Some(r) if std::mem::discriminant(&r) == std::mem::discriminant(&expected)),
+        "expected {:?} for {:?}", expected, common,
+      );
+    }
+  }
+
+  #[test]
+  fn resolution_three_k_falls_back_to_two_k() {
+    let request = GenerateImageRequest {
+      resolution: Some(CommonResolution::ThreeK),
+      ..base_nano_banana_2_image_request()
+    };
+    let ImageGenerationPlan::ArtcraftNanaBanana2(plan) = request.build().unwrap() else { panic!("expected ArtcraftNanaBanana2") };
+    assert!(matches!(plan.resolution, Some(Nb2Res::TwoK)));
+  }
+
+  // ── Num images ──────────────────────────────────────────────────────────────
+
+  #[test]
+  fn num_images_direct_mapping() {
+    let cases = [
+      (1, Nb2N::One),
+      (2, Nb2N::Two),
+      (3, Nb2N::Three),
+      (4, Nb2N::Four),
+    ];
+    for (count, expected) in cases {
+      let request = GenerateImageRequest { image_batch_count: Some(count), ..base_nano_banana_2_image_request() };
+      let ImageGenerationPlan::ArtcraftNanaBanana2(plan) = request.build().unwrap() else { panic!("expected ArtcraftNanaBanana2") };
+      assert!(
+        std::mem::discriminant(&plan.num_images) == std::mem::discriminant(&expected),
+        "expected {:?} for count {}", expected, count,
+      );
+    }
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/plan/artcraft/plan_generate_image_artcraft_seedream_4.rs

@@ -0,0 +1,380 @@
+use crate::api::common_aspect_ratio::CommonAspectRatio;
+use crate::api::image_list_ref::ImageListRef;
+use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+use crate::errors::artcraft_router_error::ArtcraftRouterError;
+use crate::errors::client_error::ClientError;
+use crate::generate::generate_image::generate_image_request::GenerateImageRequest;
+use artcraft_api_defs::generate::image::multi_function::bytedance_seedream_v4_multi_function_image_gen::{
+  BytedanceSeedreamV4MultiFunctionImageGenImageSize,
+  BytedanceSeedreamV4MultiFunctionImageGenNumImages,
+};
+use tokens::tokens::media_files::MediaFileToken;
+
+#[derive(Debug, Clone)]
+pub struct PlanArtcraftSeedream4<'a> {
+  pub prompt: Option<&'a str>,
+  /// Input images for image editing. None means text-to-image mode.
+  pub image_inputs: Option<&'a Vec<MediaFileToken>>,
+  pub image_size: Option<BytedanceSeedreamV4MultiFunctionImageGenImageSize>,
+  pub num_images: BytedanceSeedreamV4MultiFunctionImageGenNumImages,
+  pub idempotency_token: String,
+}
+
+pub fn plan_generate_image_artcraft_seedream_4<'a>(
+  request: &'a GenerateImageRequest<'a>,
+) -> Result<PlanArtcraftSeedream4<'a>, ArtcraftRouterError> {
+  let strategy = request.request_mismatch_mitigation_strategy;
+
+  let is_edit_mode = request.image_inputs.is_some();
+  let image_inputs = resolve_image_list_ref(request.image_inputs)?;
+  let image_size = plan_image_size(request.aspect_ratio, is_edit_mode, strategy)?;
+  let num_images = plan_num_images(request.image_batch_count, strategy)?;
+
+  Ok(PlanArtcraftSeedream4 {
+    prompt: request.prompt,
+    image_inputs,
+    image_size,
+    num_images,
+    idempotency_token: request.get_or_generate_idempotency_token(),
+  })
+}
+
+fn resolve_image_list_ref<'a>(
+  image_list_ref: Option<ImageListRef<'a>>,
+) -> Result<Option<&'a Vec<MediaFileToken>>, ArtcraftRouterError> {
+  match image_list_ref {
+    None => Ok(None),
+    Some(ImageListRef::MediaFileTokens(tokens)) => Ok(Some(tokens)),
+    Some(ImageListRef::Urls(_)) => {
+      Err(ArtcraftRouterError::Client(ClientError::ArtcraftOnlySupportsMediaTokens))
+    }
+  }
+}
+
+// Seedream V4 supported image sizes:
+//   Square, SquareHd
+//   PortraitFourThree, PortraitSixteenNine
+//   LandscapeFourThree, LandscapeSixteenNine
+//   Auto (edit mode: preserve source dimensions), Auto2k, Auto4k
+fn plan_image_size(
+  aspect_ratio: Option<CommonAspectRatio>,
+  is_edit_mode: bool,
+  strategy: RequestMismatchMitigationStrategy,
+) -> Result<Option<BytedanceSeedreamV4MultiFunctionImageGenImageSize>, ArtcraftRouterError> {
+  use BytedanceSeedreamV4MultiFunctionImageGenImageSize as S;
+  match aspect_ratio {
+    None => Ok(None),
+
+    // Auto: valid in edit mode (preserve source dimensions); fall back to Square for text-to-image
+    Some(CommonAspectRatio::Auto) => {
+      if is_edit_mode { Ok(Some(S::Auto)) } else { Ok(Some(S::Square)) }
+    }
+
+    Some(CommonAspectRatio::Auto2k) => Ok(Some(S::Auto2k)),
+    Some(CommonAspectRatio::Auto4k) => Ok(Some(S::Auto4k)),
+
+    // Square
+    Some(CommonAspectRatio::Square) => Ok(Some(S::Square)),
+    Some(CommonAspectRatio::SquareHd) => Ok(Some(S::SquareHd)),
+
+    // Wide — direct mappings
+    Some(CommonAspectRatio::Wide) | Some(CommonAspectRatio::WideSixteenByNine) => Ok(Some(S::LandscapeSixteenNine)),
+    Some(CommonAspectRatio::WideFourByThree) => Ok(Some(S::LandscapeFourThree)),
+
+    // Wide — no direct equivalent, nearest is LandscapeSixteenNine
+    Some(unsupported @ CommonAspectRatio::WideFiveByFour)
+    | Some(unsupported @ CommonAspectRatio::WideThreeByTwo)
+    | Some(unsupported @ CommonAspectRatio::WideTwentyOneByNine) => match strategy {
+      RequestMismatchMitigationStrategy::ErrorOut => {
+        Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+          field: "aspect_ratio",
+          value: format!("{:?}", unsupported),
+        }))
+      }
+      RequestMismatchMitigationStrategy::PayMoreUpgrade
+      | RequestMismatchMitigationStrategy::PayLessDowngrade => Ok(Some(S::LandscapeSixteenNine)),
+    },
+
+    // Tall — direct mappings
+    Some(CommonAspectRatio::Tall) | Some(CommonAspectRatio::TallNineBySixteen) => Ok(Some(S::PortraitSixteenNine)),
+    Some(CommonAspectRatio::TallThreeByFour) => Ok(Some(S::PortraitFourThree)),
+
+    // Tall — no direct equivalent, nearest is PortraitSixteenNine
+    Some(unsupported @ CommonAspectRatio::TallFourByFive)
+    | Some(unsupported @ CommonAspectRatio::TallTwoByThree)
+    | Some(unsupported @ CommonAspectRatio::TallNineByTwentyOne) => match strategy {
+      RequestMismatchMitigationStrategy::ErrorOut => {
+        Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+          field: "aspect_ratio",
+          value: format!("{:?}", unsupported),
+        }))
+      }
+      RequestMismatchMitigationStrategy::PayMoreUpgrade
+      | RequestMismatchMitigationStrategy::PayLessDowngrade => Ok(Some(S::PortraitSixteenNine)),
+    },
+  }
+}
+
+fn plan_num_images(
+  image_batch_count: Option<u16>,
+  strategy: RequestMismatchMitigationStrategy,
+) -> Result<BytedanceSeedreamV4MultiFunctionImageGenNumImages, ArtcraftRouterError> {
+  use BytedanceSeedreamV4MultiFunctionImageGenNumImages as N;
+  let count = image_batch_count.unwrap_or(1);
+  match count {
+    0 => Err(ArtcraftRouterError::Client(ClientError::UserRequestedZeroGenerations)),
+    1 => Ok(N::One),
+    2 => Ok(N::Two),
+    3 => Ok(N::Three),
+    4 => Ok(N::Four),
+    _ => match strategy {
+      RequestMismatchMitigationStrategy::ErrorOut => {
+        Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+          field: "image_batch_count",
+          value: format!("{}", count),
+        }))
+      }
+      RequestMismatchMitigationStrategy::PayMoreUpgrade
+      | RequestMismatchMitigationStrategy::PayLessDowngrade => Ok(N::Four),
+    },
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+  use crate::api::common_aspect_ratio::CommonAspectRatio;
+  use crate::api::image_list_ref::ImageListRef;
+  use crate::errors::artcraft_router_error::ArtcraftRouterError;
+  use crate::errors::client_error::ClientError;
+  use crate::generate::generate_image::image_generation_plan::ImageGenerationPlan;
+  use crate::test_helpers::base_seedream_4_image_request;
+  use artcraft_api_defs::generate::image::multi_function::bytedance_seedream_v4_multi_function_image_gen::{
+    BytedanceSeedreamV4MultiFunctionImageGenImageSize as S,
+    BytedanceSeedreamV4MultiFunctionImageGenNumImages as N,
+  };
+
+  // ── Image size (from aspect ratio) ──────────────────────────────────────────
+
+  #[test]
+  fn image_size_none_is_none() {
+    let request = GenerateImageRequest { aspect_ratio: None, ..base_seedream_4_image_request() };
+    let ImageGenerationPlan::ArtcraftSeedream4(plan) = request.build().unwrap() else { panic!("expected ArtcraftSeedream4") };
+    assert!(plan.image_size.is_none());
+  }
+
+  #[test]
+  fn image_size_square() {
+    for ar in [CommonAspectRatio::Square, CommonAspectRatio::SquareHd] {
+      let request = GenerateImageRequest { aspect_ratio: Some(ar), ..base_seedream_4_image_request() };
+      let ImageGenerationPlan::ArtcraftSeedream4(plan) = request.build().unwrap() else { panic!("expected ArtcraftSeedream4") };
+      let expected = match ar {
+        CommonAspectRatio::Square => S::Square,
+        CommonAspectRatio::SquareHd => S::SquareHd,
+        _ => unreachable!(),
+      };
+      assert!(
+        matches!(plan.image_size, Some(s) if std::mem::discriminant(&s) == std::mem::discriminant(&expected)),
+        "expected {:?} for {:?}", expected, ar,
+      );
+    }
+  }
+
+  #[test]
+  fn image_size_wide_direct() {
+    let cases = [
+      (CommonAspectRatio::Wide, S::LandscapeSixteenNine),
+      (CommonAspectRatio::WideSixteenByNine, S::LandscapeSixteenNine),
+      (CommonAspectRatio::WideFourByThree, S::LandscapeFourThree),
+    ];
+    for (ar, expected) in cases {
+      let request = GenerateImageRequest { aspect_ratio: Some(ar), ..base_seedream_4_image_request() };
+      let ImageGenerationPlan::ArtcraftSeedream4(plan) = request.build().unwrap() else { panic!("expected ArtcraftSeedream4") };
+      assert!(
+        matches!(plan.image_size, Some(s) if std::mem::discriminant(&s) == std::mem::discriminant(&expected)),
+        "expected {:?} for {:?}", expected, ar,
+      );
+    }
+  }
+
+  #[test]
+  fn image_size_tall_direct() {
+    let cases = [
+      (CommonAspectRatio::Tall, S::PortraitSixteenNine),
+      (CommonAspectRatio::TallNineBySixteen, S::PortraitSixteenNine),
+      (CommonAspectRatio::TallThreeByFour, S::PortraitFourThree),
+    ];
+    for (ar, expected) in cases {
+      let request = GenerateImageRequest { aspect_ratio: Some(ar), ..base_seedream_4_image_request() };
+      let ImageGenerationPlan::ArtcraftSeedream4(plan) = request.build().unwrap() else { panic!("expected ArtcraftSeedream4") };
+      assert!(
+        matches!(plan.image_size, Some(s) if std::mem::discriminant(&s) == std::mem::discriminant(&expected)),
+        "expected {:?} for {:?}", expected, ar,
+      );
+    }
+  }
+
+  #[test]
+  fn image_size_auto_in_edit_mode_yields_auto() {
+    let tokens = vec![];
+    let request = GenerateImageRequest {
+      aspect_ratio: Some(CommonAspectRatio::Auto),
+      image_inputs: Some(ImageListRef::MediaFileTokens(&tokens)),
+      ..base_seedream_4_image_request()
+    };
+    let ImageGenerationPlan::ArtcraftSeedream4(plan) = request.build().unwrap() else { panic!("expected ArtcraftSeedream4") };
+    assert!(matches!(plan.image_size, Some(S::Auto)));
+  }
+
+  #[test]
+  fn image_size_auto_in_text_to_image_yields_square() {
+    let request = GenerateImageRequest {
+      aspect_ratio: Some(CommonAspectRatio::Auto),
+      image_inputs: None,
+      ..base_seedream_4_image_request()
+    };
+    let ImageGenerationPlan::ArtcraftSeedream4(plan) = request.build().unwrap() else { panic!("expected ArtcraftSeedream4") };
+    assert!(matches!(plan.image_size, Some(S::Square)));
+  }
+
+  #[test]
+  fn image_size_auto2k_and_auto4k() {
+    for (ar, expected) in [(CommonAspectRatio::Auto2k, S::Auto2k), (CommonAspectRatio::Auto4k, S::Auto4k)] {
+      let request = GenerateImageRequest { aspect_ratio: Some(ar), ..base_seedream_4_image_request() };
+      let ImageGenerationPlan::ArtcraftSeedream4(plan) = request.build().unwrap() else { panic!("expected ArtcraftSeedream4") };
+      assert!(
+        matches!(plan.image_size, Some(s) if std::mem::discriminant(&s) == std::mem::discriminant(&expected)),
+        "expected {:?} for {:?}", expected, ar,
+      );
+    }
+  }
+
+  #[test]
+  fn image_size_unsupported_error_out() {
+    for ar in [CommonAspectRatio::WideFiveByFour, CommonAspectRatio::TallFourByFive] {
+      let request = GenerateImageRequest {
+        aspect_ratio: Some(ar),
+        request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+        ..base_seedream_4_image_request()
+      };
+      assert!(matches!(
+        request.build(),
+        Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption { .. }))
+      ), "expected error for {:?}", ar);
+    }
+  }
+
+  #[test]
+  fn image_size_unsupported_nearest_match() {
+    for strategy in [RequestMismatchMitigationStrategy::PayMoreUpgrade, RequestMismatchMitigationStrategy::PayLessDowngrade] {
+      let request = GenerateImageRequest {
+        aspect_ratio: Some(CommonAspectRatio::WideFiveByFour),
+        request_mismatch_mitigation_strategy: strategy,
+        ..base_seedream_4_image_request()
+      };
+      let ImageGenerationPlan::ArtcraftSeedream4(plan) = request.build().unwrap() else { panic!("expected ArtcraftSeedream4") };
+      assert!(matches!(plan.image_size, Some(S::LandscapeSixteenNine)), "expected LandscapeSixteenNine with {:?}", strategy);
+
+      let request = GenerateImageRequest {
+        aspect_ratio: Some(CommonAspectRatio::TallFourByFive),
+        request_mismatch_mitigation_strategy: strategy,
+        ..base_seedream_4_image_request()
+      };
+      let ImageGenerationPlan::ArtcraftSeedream4(plan) = request.build().unwrap() else { panic!("expected ArtcraftSeedream4") };
+      assert!(matches!(plan.image_size, Some(S::PortraitSixteenNine)), "expected PortraitSixteenNine with {:?}", strategy);
+    }
+  }
+
+  // ── Num images ──────────────────────────────────────────────────────────────
+
+  #[test]
+  fn num_images_zero_is_always_error() {
+    for strategy in [
+      RequestMismatchMitigationStrategy::ErrorOut,
+      RequestMismatchMitigationStrategy::PayMoreUpgrade,
+      RequestMismatchMitigationStrategy::PayLessDowngrade,
+    ] {
+      let request = GenerateImageRequest {
+        image_batch_count: Some(0),
+        request_mismatch_mitigation_strategy: strategy,
+        ..base_seedream_4_image_request()
+      };
+      assert!(
+        matches!(request.build(), Err(ArtcraftRouterError::Client(ClientError::UserRequestedZeroGenerations))),
+        "expected UserRequestedZeroGenerations with {:?}", strategy,
+      );
+    }
+  }
+
+  #[test]
+  fn num_images_direct_mapping() {
+    let cases = [(1, N::One), (2, N::Two), (3, N::Three), (4, N::Four)];
+    for (count, expected) in cases {
+      let request = GenerateImageRequest { image_batch_count: Some(count), ..base_seedream_4_image_request() };
+      let ImageGenerationPlan::ArtcraftSeedream4(plan) = request.build().unwrap() else { panic!("expected ArtcraftSeedream4") };
+      assert!(
+        std::mem::discriminant(&plan.num_images) == std::mem::discriminant(&expected),
+        "expected {:?} for count {}", expected, count,
+      );
+    }
+  }
+
+  #[test]
+  fn num_images_out_of_range_error_out() {
+    let request = GenerateImageRequest {
+      image_batch_count: Some(5),
+      request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+      ..base_seedream_4_image_request()
+    };
+    assert!(matches!(
+      request.build(),
+      Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption { .. }))
+    ));
+  }
+
+  #[test]
+  fn num_images_out_of_range_clamps_to_four() {
+    for strategy in [RequestMismatchMitigationStrategy::PayMoreUpgrade, RequestMismatchMitigationStrategy::PayLessDowngrade] {
+      let request = GenerateImageRequest {
+        image_batch_count: Some(5),
+        request_mismatch_mitigation_strategy: strategy,
+        ..base_seedream_4_image_request()
+      };
+      let ImageGenerationPlan::ArtcraftSeedream4(plan) = request.build().unwrap() else { panic!("expected ArtcraftSeedream4") };
+      assert!(matches!(plan.num_images, N::Four), "expected Four for count 5 with {:?}", strategy);
+    }
+  }
+
+  // ── Image inputs ──────────────────────────────────────────────────────────
+
+  #[test]
+  fn url_image_inputs_returns_error() {
+    let urls = vec!["https://example.com/image.jpg".to_string()];
+    let request = GenerateImageRequest {
+      image_inputs: Some(ImageListRef::Urls(&urls)),
+      ..base_seedream_4_image_request()
+    };
+    assert!(matches!(
+      request.build(),
+      Err(ArtcraftRouterError::Client(ClientError::ArtcraftOnlySupportsMediaTokens))
+    ));
+  }
+
+  #[test]
+  fn no_image_inputs_is_text_to_image_mode() {
+    let request = GenerateImageRequest { image_inputs: None, ..base_seedream_4_image_request() };
+    let ImageGenerationPlan::ArtcraftSeedream4(plan) = request.build().unwrap() else { panic!("expected ArtcraftSeedream4") };
+    assert!(plan.image_inputs.is_none());
+  }
+
+  #[test]
+  fn media_token_image_inputs_is_edit_mode() {
+    let tokens = vec![];
+    let request = GenerateImageRequest {
+      image_inputs: Some(ImageListRef::MediaFileTokens(&tokens)),
+      ..base_seedream_4_image_request()
+    };
+    let ImageGenerationPlan::ArtcraftSeedream4(plan) = request.build().unwrap() else { panic!("expected ArtcraftSeedream4") };
+    assert!(plan.image_inputs.is_some());
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/plan/artcraft/plan_generate_image_artcraft_seedream_4p5.rs

@@ -0,0 +1,381 @@
+use crate::api::common_aspect_ratio::CommonAspectRatio;
+use crate::api::image_list_ref::ImageListRef;
+use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+use crate::errors::artcraft_router_error::ArtcraftRouterError;
+use crate::errors::client_error::ClientError;
+use crate::generate::generate_image::generate_image_request::GenerateImageRequest;
+use artcraft_api_defs::generate::image::multi_function::bytedance_seedream_v4p5_multi_function_image_gen::{
+  BytedanceSeedreamV4p5MultiFunctionImageGenImageSize,
+  BytedanceSeedreamV4p5MultiFunctionImageGenNumImages,
+};
+use tokens::tokens::media_files::MediaFileToken;
+
+#[derive(Debug, Clone)]
+pub struct PlanArtcraftSeedream4p5<'a> {
+  pub prompt: Option<&'a str>,
+  /// Input images for image editing. None means text-to-image mode.
+  pub image_inputs: Option<&'a Vec<MediaFileToken>>,
+  pub image_size: Option<BytedanceSeedreamV4p5MultiFunctionImageGenImageSize>,
+  pub num_images: BytedanceSeedreamV4p5MultiFunctionImageGenNumImages,
+  pub idempotency_token: String,
+}
+
+pub fn plan_generate_image_artcraft_seedream_4p5<'a>(
+  request: &'a GenerateImageRequest<'a>,
+) -> Result<PlanArtcraftSeedream4p5<'a>, ArtcraftRouterError> {
+  let strategy = request.request_mismatch_mitigation_strategy;
+
+  let is_edit_mode = request.image_inputs.is_some();
+  let image_inputs = resolve_image_list_ref(request.image_inputs)?;
+  let image_size = plan_image_size(request.aspect_ratio, is_edit_mode, strategy)?;
+  let num_images = plan_num_images(request.image_batch_count, strategy)?;
+
+  Ok(PlanArtcraftSeedream4p5 {
+    prompt: request.prompt,
+    image_inputs,
+    image_size,
+    num_images,
+    idempotency_token: request.get_or_generate_idempotency_token(),
+  })
+}
+
+fn resolve_image_list_ref<'a>(
+  image_list_ref: Option<ImageListRef<'a>>,
+) -> Result<Option<&'a Vec<MediaFileToken>>, ArtcraftRouterError> {
+  match image_list_ref {
+    None => Ok(None),
+    Some(ImageListRef::MediaFileTokens(tokens)) => Ok(Some(tokens)),
+    Some(ImageListRef::Urls(_)) => {
+      Err(ArtcraftRouterError::Client(ClientError::ArtcraftOnlySupportsMediaTokens))
+    }
+  }
+}
+
+// Seedream V4.5 supported image sizes:
+//   Square, SquareHd
+//   PortraitFourThree, PortraitSixteenNine
+//   LandscapeFourThree, LandscapeSixteenNine
+//   Auto2k, Auto4k (no bare Auto — unlike V4)
+fn plan_image_size(
+  aspect_ratio: Option<CommonAspectRatio>,
+  is_edit_mode: bool,
+  strategy: RequestMismatchMitigationStrategy,
+) -> Result<Option<BytedanceSeedreamV4p5MultiFunctionImageGenImageSize>, ArtcraftRouterError> {
+  use BytedanceSeedreamV4p5MultiFunctionImageGenImageSize as S;
+  match aspect_ratio {
+    None => Ok(None),
+
+    // Auto: V4.5 has no bare Auto; fall back to Auto2k in edit mode, Square for text-to-image
+    Some(CommonAspectRatio::Auto) => {
+      if is_edit_mode { Ok(Some(S::Auto2k)) } else { Ok(Some(S::Square)) }
+    }
+
+    Some(CommonAspectRatio::Auto2k) => Ok(Some(S::Auto2k)),
+    Some(CommonAspectRatio::Auto4k) => Ok(Some(S::Auto4k)),
+
+    // Square
+    Some(CommonAspectRatio::Square) => Ok(Some(S::Square)),
+    Some(CommonAspectRatio::SquareHd) => Ok(Some(S::SquareHd)),
+
+    // Wide — direct mappings
+    Some(CommonAspectRatio::Wide) | Some(CommonAspectRatio::WideSixteenByNine) => Ok(Some(S::LandscapeSixteenNine)),
+    Some(CommonAspectRatio::WideFourByThree) => Ok(Some(S::LandscapeFourThree)),
+
+    // Wide — no direct equivalent, nearest is LandscapeSixteenNine
+    Some(unsupported @ CommonAspectRatio::WideFiveByFour)
+    | Some(unsupported @ CommonAspectRatio::WideThreeByTwo)
+    | Some(unsupported @ CommonAspectRatio::WideTwentyOneByNine) => match strategy {
+      RequestMismatchMitigationStrategy::ErrorOut => {
+        Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+          field: "aspect_ratio",
+          value: format!("{:?}", unsupported),
+        }))
+      }
+      RequestMismatchMitigationStrategy::PayMoreUpgrade
+      | RequestMismatchMitigationStrategy::PayLessDowngrade => Ok(Some(S::LandscapeSixteenNine)),
+    },
+
+    // Tall — direct mappings
+    Some(CommonAspectRatio::Tall) | Some(CommonAspectRatio::TallNineBySixteen) => Ok(Some(S::PortraitSixteenNine)),
+    Some(CommonAspectRatio::TallThreeByFour) => Ok(Some(S::PortraitFourThree)),
+
+    // Tall — no direct equivalent, nearest is PortraitSixteenNine
+    Some(unsupported @ CommonAspectRatio::TallFourByFive)
+    | Some(unsupported @ CommonAspectRatio::TallTwoByThree)
+    | Some(unsupported @ CommonAspectRatio::TallNineByTwentyOne) => match strategy {
+      RequestMismatchMitigationStrategy::ErrorOut => {
+        Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+          field: "aspect_ratio",
+          value: format!("{:?}", unsupported),
+        }))
+      }
+      RequestMismatchMitigationStrategy::PayMoreUpgrade
+      | RequestMismatchMitigationStrategy::PayLessDowngrade => Ok(Some(S::PortraitSixteenNine)),
+    },
+  }
+}
+
+fn plan_num_images(
+  image_batch_count: Option<u16>,
+  strategy: RequestMismatchMitigationStrategy,
+) -> Result<BytedanceSeedreamV4p5MultiFunctionImageGenNumImages, ArtcraftRouterError> {
+  use BytedanceSeedreamV4p5MultiFunctionImageGenNumImages as N;
+  let count = image_batch_count.unwrap_or(1);
+  match count {
+    0 => Err(ArtcraftRouterError::Client(ClientError::UserRequestedZeroGenerations)),
+    1 => Ok(N::One),
+    2 => Ok(N::Two),
+    3 => Ok(N::Three),
+    4 => Ok(N::Four),
+    _ => match strategy {
+      RequestMismatchMitigationStrategy::ErrorOut => {
+        Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+          field: "image_batch_count",
+          value: format!("{}", count),
+        }))
+      }
+      RequestMismatchMitigationStrategy::PayMoreUpgrade
+      | RequestMismatchMitigationStrategy::PayLessDowngrade => Ok(N::Four),
+    },
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+  use crate::api::common_aspect_ratio::CommonAspectRatio;
+  use crate::api::image_list_ref::ImageListRef;
+  use crate::errors::artcraft_router_error::ArtcraftRouterError;
+  use crate::errors::client_error::ClientError;
+  use crate::generate::generate_image::image_generation_plan::ImageGenerationPlan;
+  use crate::test_helpers::base_seedream_4p5_image_request;
+  use artcraft_api_defs::generate::image::multi_function::bytedance_seedream_v4p5_multi_function_image_gen::{
+    BytedanceSeedreamV4p5MultiFunctionImageGenImageSize as S,
+    BytedanceSeedreamV4p5MultiFunctionImageGenNumImages as N,
+  };
+
+  // ── Image size (from aspect ratio) ──────────────────────────────────────────
+
+  #[test]
+  fn image_size_none_is_none() {
+    let request = GenerateImageRequest { aspect_ratio: None, ..base_seedream_4p5_image_request() };
+    let ImageGenerationPlan::ArtcraftSeedream4p5(plan) = request.build().unwrap() else { panic!("expected ArtcraftSeedream4p5") };
+    assert!(plan.image_size.is_none());
+  }
+
+  #[test]
+  fn image_size_square() {
+    for ar in [CommonAspectRatio::Square, CommonAspectRatio::SquareHd] {
+      let request = GenerateImageRequest { aspect_ratio: Some(ar), ..base_seedream_4p5_image_request() };
+      let ImageGenerationPlan::ArtcraftSeedream4p5(plan) = request.build().unwrap() else { panic!("expected ArtcraftSeedream4p5") };
+      let expected = match ar {
+        CommonAspectRatio::Square => S::Square,
+        CommonAspectRatio::SquareHd => S::SquareHd,
+        _ => unreachable!(),
+      };
+      assert!(
+        matches!(plan.image_size, Some(s) if std::mem::discriminant(&s) == std::mem::discriminant(&expected)),
+        "expected {:?} for {:?}", expected, ar,
+      );
+    }
+  }
+
+  #[test]
+  fn image_size_wide_direct() {
+    let cases = [
+      (CommonAspectRatio::Wide, S::LandscapeSixteenNine),
+      (CommonAspectRatio::WideSixteenByNine, S::LandscapeSixteenNine),
+      (CommonAspectRatio::WideFourByThree, S::LandscapeFourThree),
+    ];
+    for (ar, expected) in cases {
+      let request = GenerateImageRequest { aspect_ratio: Some(ar), ..base_seedream_4p5_image_request() };
+      let ImageGenerationPlan::ArtcraftSeedream4p5(plan) = request.build().unwrap() else { panic!("expected ArtcraftSeedream4p5") };
+      assert!(
+        matches!(plan.image_size, Some(s) if std::mem::discriminant(&s) == std::mem::discriminant(&expected)),
+        "expected {:?} for {:?}", expected, ar,
+      );
+    }
+  }
+
+  #[test]
+  fn image_size_tall_direct() {
+    let cases = [
+      (CommonAspectRatio::Tall, S::PortraitSixteenNine),
+      (CommonAspectRatio::TallNineBySixteen, S::PortraitSixteenNine),
+      (CommonAspectRatio::TallThreeByFour, S::PortraitFourThree),
+    ];
+    for (ar, expected) in cases {
+      let request = GenerateImageRequest { aspect_ratio: Some(ar), ..base_seedream_4p5_image_request() };
+      let ImageGenerationPlan::ArtcraftSeedream4p5(plan) = request.build().unwrap() else { panic!("expected ArtcraftSeedream4p5") };
+      assert!(
+        matches!(plan.image_size, Some(s) if std::mem::discriminant(&s) == std::mem::discriminant(&expected)),
+        "expected {:?} for {:?}", expected, ar,
+      );
+    }
+  }
+
+  #[test]
+  fn image_size_auto_in_edit_mode_yields_auto2k() {
+    // V4.5 has no bare Auto; falls back to Auto2k in edit mode
+    let tokens = vec![];
+    let request = GenerateImageRequest {
+      aspect_ratio: Some(CommonAspectRatio::Auto),
+      image_inputs: Some(ImageListRef::MediaFileTokens(&tokens)),
+      ..base_seedream_4p5_image_request()
+    };
+    let ImageGenerationPlan::ArtcraftSeedream4p5(plan) = request.build().unwrap() else { panic!("expected ArtcraftSeedream4p5") };
+    assert!(matches!(plan.image_size, Some(S::Auto2k)));
+  }
+
+  #[test]
+  fn image_size_auto_in_text_to_image_yields_square() {
+    let request = GenerateImageRequest {
+      aspect_ratio: Some(CommonAspectRatio::Auto),
+      image_inputs: None,
+      ..base_seedream_4p5_image_request()
+    };
+    let ImageGenerationPlan::ArtcraftSeedream4p5(plan) = request.build().unwrap() else { panic!("expected ArtcraftSeedream4p5") };
+    assert!(matches!(plan.image_size, Some(S::Square)));
+  }
+
+  #[test]
+  fn image_size_auto2k_and_auto4k() {
+    for (ar, expected) in [(CommonAspectRatio::Auto2k, S::Auto2k), (CommonAspectRatio::Auto4k, S::Auto4k)] {
+      let request = GenerateImageRequest { aspect_ratio: Some(ar), ..base_seedream_4p5_image_request() };
+      let ImageGenerationPlan::ArtcraftSeedream4p5(plan) = request.build().unwrap() else { panic!("expected ArtcraftSeedream4p5") };
+      assert!(
+        matches!(plan.image_size, Some(s) if std::mem::discriminant(&s) == std::mem::discriminant(&expected)),
+        "expected {:?} for {:?}", expected, ar,
+      );
+    }
+  }
+
+  #[test]
+  fn image_size_unsupported_error_out() {
+    for ar in [CommonAspectRatio::WideFiveByFour, CommonAspectRatio::TallFourByFive] {
+      let request = GenerateImageRequest {
+        aspect_ratio: Some(ar),
+        request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+        ..base_seedream_4p5_image_request()
+      };
+      assert!(matches!(
+        request.build(),
+        Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption { .. }))
+      ), "expected error for {:?}", ar);
+    }
+  }
+
+  #[test]
+  fn image_size_unsupported_nearest_match() {
+    for strategy in [RequestMismatchMitigationStrategy::PayMoreUpgrade, RequestMismatchMitigationStrategy::PayLessDowngrade] {
+      let request = GenerateImageRequest {
+        aspect_ratio: Some(CommonAspectRatio::WideFiveByFour),
+        request_mismatch_mitigation_strategy: strategy,
+        ..base_seedream_4p5_image_request()
+      };
+      let ImageGenerationPlan::ArtcraftSeedream4p5(plan) = request.build().unwrap() else { panic!("expected ArtcraftSeedream4p5") };
+      assert!(matches!(plan.image_size, Some(S::LandscapeSixteenNine)), "expected LandscapeSixteenNine with {:?}", strategy);
+
+      let request = GenerateImageRequest {
+        aspect_ratio: Some(CommonAspectRatio::TallFourByFive),
+        request_mismatch_mitigation_strategy: strategy,
+        ..base_seedream_4p5_image_request()
+      };
+      let ImageGenerationPlan::ArtcraftSeedream4p5(plan) = request.build().unwrap() else { panic!("expected ArtcraftSeedream4p5") };
+      assert!(matches!(plan.image_size, Some(S::PortraitSixteenNine)), "expected PortraitSixteenNine with {:?}", strategy);
+    }
+  }
+
+  // ── Num images ──────────────────────────────────────────────────────────────
+
+  #[test]
+  fn num_images_zero_is_always_error() {
+    for strategy in [
+      RequestMismatchMitigationStrategy::ErrorOut,
+      RequestMismatchMitigationStrategy::PayMoreUpgrade,
+      RequestMismatchMitigationStrategy::PayLessDowngrade,
+    ] {
+      let request = GenerateImageRequest {
+        image_batch_count: Some(0),
+        request_mismatch_mitigation_strategy: strategy,
+        ..base_seedream_4p5_image_request()
+      };
+      assert!(
+        matches!(request.build(), Err(ArtcraftRouterError::Client(ClientError::UserRequestedZeroGenerations))),
+        "expected UserRequestedZeroGenerations with {:?}", strategy,
+      );
+    }
+  }
+
+  #[test]
+  fn num_images_direct_mapping() {
+    let cases = [(1, N::One), (2, N::Two), (3, N::Three), (4, N::Four)];
+    for (count, expected) in cases {
+      let request = GenerateImageRequest { image_batch_count: Some(count), ..base_seedream_4p5_image_request() };
+      let ImageGenerationPlan::ArtcraftSeedream4p5(plan) = request.build().unwrap() else { panic!("expected ArtcraftSeedream4p5") };
+      assert!(
+        std::mem::discriminant(&plan.num_images) == std::mem::discriminant(&expected),
+        "expected {:?} for count {}", expected, count,
+      );
+    }
+  }
+
+  #[test]
+  fn num_images_out_of_range_error_out() {
+    let request = GenerateImageRequest {
+      image_batch_count: Some(5),
+      request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+      ..base_seedream_4p5_image_request()
+    };
+    assert!(matches!(
+      request.build(),
+      Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption { .. }))
+    ));
+  }
+
+  #[test]
+  fn num_images_out_of_range_clamps_to_four() {
+    for strategy in [RequestMismatchMitigationStrategy::PayMoreUpgrade, RequestMismatchMitigationStrategy::PayLessDowngrade] {
+      let request = GenerateImageRequest {
+        image_batch_count: Some(5),
+        request_mismatch_mitigation_strategy: strategy,
+        ..base_seedream_4p5_image_request()
+      };
+      let ImageGenerationPlan::ArtcraftSeedream4p5(plan) = request.build().unwrap() else { panic!("expected ArtcraftSeedream4p5") };
+      assert!(matches!(plan.num_images, N::Four), "expected Four for count 5 with {:?}", strategy);
+    }
+  }
+
+  // ── Image inputs ──────────────────────────────────────────────────────────
+
+  #[test]
+  fn url_image_inputs_returns_error() {
+    let urls = vec!["https://example.com/image.jpg".to_string()];
+    let request = GenerateImageRequest {
+      image_inputs: Some(ImageListRef::Urls(&urls)),
+      ..base_seedream_4p5_image_request()
+    };
+    assert!(matches!(
+      request.build(),
+      Err(ArtcraftRouterError::Client(ClientError::ArtcraftOnlySupportsMediaTokens))
+    ));
+  }
+
+  #[test]
+  fn no_image_inputs_is_text_to_image_mode() {
+    let request = GenerateImageRequest { image_inputs: None, ..base_seedream_4p5_image_request() };
+    let ImageGenerationPlan::ArtcraftSeedream4p5(plan) = request.build().unwrap() else { panic!("expected ArtcraftSeedream4p5") };
+    assert!(plan.image_inputs.is_none());
+  }
+
+  #[test]
+  fn media_token_image_inputs_is_edit_mode() {
+    let tokens = vec![];
+    let request = GenerateImageRequest {
+      image_inputs: Some(ImageListRef::MediaFileTokens(&tokens)),
+      ..base_seedream_4p5_image_request()
+    };
+    let ImageGenerationPlan::ArtcraftSeedream4p5(plan) = request.build().unwrap() else { panic!("expected ArtcraftSeedream4p5") };
+    assert!(plan.image_inputs.is_some());
+  }
+}