Feature: z-image + metadata node

invokeai/app/invocations/metadata_linked.py

@@ -52,6 +52,7 @@
 )
 from invokeai.app.invocations.scheduler import SchedulerOutput
 from invokeai.app.invocations.t2i_adapter import T2IAdapterField, T2IAdapterInvocation
+from invokeai.app.invocations.z_image_denoise import ZImageDenoiseInvocation
 from invokeai.app.services.shared.invocation_context import InvocationContext
 from invokeai.backend.model_manager.taxonomy import BaseModelType, ModelType, SubModelType
 from invokeai.backend.stable_diffusion.schedulers.schedulers import SCHEDULER_NAME_VALUES
@@ -729,6 +730,52 @@ def _loras_to_json(obj: Union[Any, list[Any]]):
         return LatentsMetaOutput(**params, metadata=MetadataField.model_validate(md))
 
 
+@invocation(
+    "z_image_denoise_meta",
+    title=f"{ZImageDenoiseInvocation.UIConfig.title} + Metadata",
+    tags=["z-image", "latents", "denoise", "txt2img", "t2i", "t2l", "img2img", "i2i", "l2l"],
+    category="latents",
+    version="1.0.0",
+)
+class ZImageDenoiseMetaInvocation(ZImageDenoiseInvocation, WithMetadata):
+    """Run denoising process with a Z-Image transformer model + metadata."""
+
+    def invoke(self, context: InvocationContext) -> LatentsMetaOutput:
+        def _loras_to_json(obj: Union[Any, list[Any]]):
+            if not isinstance(obj, list):
+                obj = [obj]
+
+            output: list[dict[str, Any]] = []
+            for item in obj:
+                output.append(
+                    LoRAMetadataField(
+                        model=item.lora,
+                        weight=item.weight,
+                    ).model_dump(exclude_none=True, exclude={"id", "type", "is_intermediate", "use_cache"})
+                )
+            return output
+
+        obj = super().invoke(context)
+
+        md: Dict[str, Any] = {} if self.metadata is None else self.metadata.root
+        md.update({"width": obj.width})
+        md.update({"height": obj.height})
+        md.update({"steps": self.steps})
+        md.update({"guidance": self.guidance_scale})
+        md.update({"denoising_start": self.denoising_start})
+        md.update({"denoising_end": self.denoising_end})
+        md.update({"scheduler": self.scheduler})
+        md.update({"model": self.transformer.transformer})
+        md.update({"seed": self.seed})
+        if len(self.transformer.loras) > 0:
+            md.update({"loras": _loras_to_json(self.transformer.loras)})
+
+        params = obj.__dict__.copy()
+        del params["type"]
+
+        return LatentsMetaOutput(**params, metadata=MetadataField.model_validate(md))
+
+
 @invocation(
     "metadata_to_vae",
     title="Metadata To VAE",

invokeai/frontend/web/src/features/metadata/parsing.tsx

@@ -725,6 +725,8 @@ const Qwen3EncoderModel: SingleMetadataHandler<ModelIdentifierField> = {
     return Promise.resolve(parsed);
   },
   recall: (value, store) => {
+    // Clear conflicting Qwen3Source when setting Encoder (mutually exclusive)
+    store.dispatch(zImageQwen3SourceModelSelected(null));
     store.dispatch(zImageQwen3EncoderModelSelected(value));
   },
   i18nKey: 'metadata.qwen3Encoder',
@@ -749,6 +751,8 @@ const ZImageVAEModel: SingleMetadataHandler<ModelIdentifierField> = {
     return Promise.resolve(parsed);
   },
   recall: (value, store) => {
+    // Clear conflicting Qwen3Source when setting VAE (mutually exclusive)
+    store.dispatch(zImageQwen3SourceModelSelected(null));
     store.dispatch(zImageVaeModelSelected(value));
   },
   i18nKey: 'metadata.vae',
@@ -773,6 +777,9 @@ const ZImageQwen3SourceModel: SingleMetadataHandler<ModelIdentifierField> = {
     return Promise.resolve(parsed);
   },
   recall: (value, store) => {
+    // Clear conflicting VAE and Encoder when setting Qwen3Source (mutually exclusive)
+    store.dispatch(zImageVaeModelSelected(null));
+    store.dispatch(zImageQwen3EncoderModelSelected(null));
     store.dispatch(zImageQwen3SourceModelSelected(value));
   },
   i18nKey: 'metadata.qwen3Source',
@@ -1000,7 +1007,6 @@ export const ImageMetadataHandlers = {
   CFGRescaleMultiplier,
   CLIPSkip,
   Guidance,
-  Scheduler,
   Width,
   Height,
   Seed,
@@ -1016,6 +1022,8 @@ export const ImageMetadataHandlers = {
   RefinerNegativeAestheticScore,
   RefinerDenoisingStart,
   MainModel,
+  // Scheduler must be after MainModel so that base-dependent logic (z-image scheduler) works correctly
+  Scheduler,
   VAEModel,
   Qwen3EncoderModel,
   ZImageVAEModel,

invokeai/frontend/web/src/features/parameters/components/Advanced/ParamZImageQwen3VaeModelSelect.tsx

@@ -17,21 +17,19 @@ import type { MainModelConfig, Qwen3EncoderModelConfig, VAEModelConfig } from 's
 
 /**
  * Z-Image VAE Model Select - uses FLUX VAE models
- * Disabled when Qwen3 Source is selected (mutually exclusive)
+ * Selecting this will clear Qwen3 Source (mutually exclusive)
  */
 const ParamZImageVaeModelSelect = memo(() => {
   const dispatch = useAppDispatch();
   const { t } = useTranslation();
   const zImageVaeModel = useAppSelector(selectZImageVaeModel);
-  const zImageQwen3SourceModel = useAppSelector(selectZImageQwen3SourceModel);
   const [modelConfigs, { isLoading }] = useFluxVAEModels();
 
-  // Disable when Qwen3 Source is selected
-  const isDisabled = zImageQwen3SourceModel !== null;
-
   const _onChange = useCallback(
     (model: VAEModelConfig | null) => {
       if (model) {
+        // Clear conflicting Qwen3Source when setting VAE
+        dispatch(zImageQwen3SourceModelSelected(null));
         dispatch(zImageVaeModelSelected(zModelIdentifierField.parse(model)));
       } else {
         dispatch(zImageVaeModelSelected(null));
@@ -48,15 +46,14 @@ const ParamZImageVaeModelSelect = memo(() => {
   });
 
   return (
-    <FormControl minW={0} flexGrow={1} gap={2} isDisabled={isDisabled}>
+    <FormControl minW={0} flexGrow={1} gap={2}>
       <FormLabel m={0}>{t('modelManager.zImageVae')}</FormLabel>
       <Combobox
         value={value}
         options={options}
         onChange={onChange}
         noOptionsMessage={noOptionsMessage}
         isClearable
-        isDisabled={isDisabled}
         placeholder={t('modelManager.zImageVaePlaceholder')}
       />
     </FormControl>
@@ -67,21 +64,19 @@ ParamZImageVaeModelSelect.displayName = 'ParamZImageVaeModelSelect';
 
 /**
  * Z-Image Qwen3 Encoder Model Select
- * Disabled when Qwen3 Source is selected (mutually exclusive)
+ * Selecting this will clear Qwen3 Source (mutually exclusive)
  */
 const ParamZImageQwen3EncoderModelSelect = memo(() => {
   const dispatch = useAppDispatch();
   const { t } = useTranslation();
   const zImageQwen3EncoderModel = useAppSelector(selectZImageQwen3EncoderModel);
-  const zImageQwen3SourceModel = useAppSelector(selectZImageQwen3SourceModel);
   const [modelConfigs, { isLoading }] = useQwen3EncoderModels();
 
-  // Disable when Qwen3 Source is selected
-  const isDisabled = zImageQwen3SourceModel !== null;
-
   const _onChange = useCallback(
     (model: Qwen3EncoderModelConfig | null) => {
       if (model) {
+        // Clear conflicting Qwen3Source when setting Encoder
+        dispatch(zImageQwen3SourceModelSelected(null));
         dispatch(zImageQwen3EncoderModelSelected(zModelIdentifierField.parse(model)));
       } else {
         dispatch(zImageQwen3EncoderModelSelected(null));
@@ -98,15 +93,14 @@ const ParamZImageQwen3EncoderModelSelect = memo(() => {
   });
 
   return (
-    <FormControl minW={0} flexGrow={1} gap={2} isDisabled={isDisabled}>
+    <FormControl minW={0} flexGrow={1} gap={2}>
       <FormLabel m={0}>{t('modelManager.zImageQwen3Encoder')}</FormLabel>
       <Combobox
         value={value}
         options={options}
         onChange={onChange}
         noOptionsMessage={noOptionsMessage}
         isClearable
-        isDisabled={isDisabled}
         placeholder={t('modelManager.zImageQwen3EncoderPlaceholder')}
       />
     </FormControl>
@@ -117,22 +111,20 @@ ParamZImageQwen3EncoderModelSelect.displayName = 'ParamZImageQwen3EncoderModelSe
 
 /**
  * Z-Image Qwen3 Source Model Select - Diffusers Z-Image models for fallback
- * Disabled when VAE or Qwen3 Encoder is selected (mutually exclusive)
+ * Selecting this will clear VAE and Qwen3 Encoder (mutually exclusive)
  */
 const ParamZImageQwen3SourceModelSelect = memo(() => {
   const dispatch = useAppDispatch();
   const { t } = useTranslation();
   const zImageQwen3SourceModel = useAppSelector(selectZImageQwen3SourceModel);
-  const zImageVaeModel = useAppSelector(selectZImageVaeModel);
-  const zImageQwen3EncoderModel = useAppSelector(selectZImageQwen3EncoderModel);
   const [modelConfigs, { isLoading }] = useZImageDiffusersModels();
 
-  // Disable when VAE or Qwen3 Encoder is selected
-  const isDisabled = zImageVaeModel !== null || zImageQwen3EncoderModel !== null;
-
   const _onChange = useCallback(
     (model: MainModelConfig | null) => {
       if (model) {
+        // Clear conflicting VAE and Encoder when setting Qwen3Source
+        dispatch(zImageVaeModelSelected(null));
+        dispatch(zImageQwen3EncoderModelSelected(null));
         dispatch(zImageQwen3SourceModelSelected(zModelIdentifierField.parse(model)));
       } else {
         dispatch(zImageQwen3SourceModelSelected(null));
@@ -149,15 +141,14 @@ const ParamZImageQwen3SourceModelSelect = memo(() => {
   });
 
   return (
-    <FormControl minW={0} flexGrow={1} gap={2} isDisabled={isDisabled}>
+    <FormControl minW={0} flexGrow={1} gap={2}>
       <FormLabel m={0}>{t('modelManager.zImageQwen3Source')}</FormLabel>
       <Combobox
         value={value}
         options={options}
         onChange={onChange}
         noOptionsMessage={noOptionsMessage}
         isClearable
-        isDisabled={isDisabled}
         placeholder={t('modelManager.zImageQwen3SourcePlaceholder')}
       />
     </FormControl>