refactor(ui): simplify graph builder handling of VAE encode and seed

invokeai/frontend/web/src/features/nodes/util/graph/generation/addImageToImage.ts

@@ -15,28 +15,26 @@ type AddImageToImageArg = {
   g: Graph;
   manager: CanvasManager;
   l2i: Invocation<LatentToImageNodes>;
-  i2lNodeType: 'i2l' | 'flux_vae_encode' | 'sd3_i2l' | 'cogview4_i2l';
+  i2l: Invocation<'i2l' | 'flux_vae_encode' | 'sd3_i2l' | 'cogview4_i2l'>;
   denoise: Invocation<DenoiseLatentsNodes>;
   vaeSource: Invocation<VaeSourceNodes | MainModelLoaderNodes>;
   originalSize: Dimensions;
   scaledSize: Dimensions;
   bbox: CanvasState['bbox'];
   denoising_start: number;
-  fp32: boolean;
 };
 
 export const addImageToImage = async ({
   g,
   manager,
   l2i,
-  i2lNodeType,
+  i2l,
   denoise,
   vaeSource,
   originalSize,
   scaledSize,
   bbox,
   denoising_start,
-  fp32,
 }: AddImageToImageArg): Promise<Invocation<'img_resize' | 'l2i' | 'flux_vae_decode' | 'sd3_l2i' | 'cogview4_l2i'>> => {
   denoise.denoising_start = denoising_start;
   const adapters = manager.compositor.getVisibleAdaptersOfType('raster_layer');
@@ -54,12 +52,7 @@ export const addImageToImage = async ({
       ...scaledSize,
     });
 
-    const i2l = g.addNode({
-      id: i2lNodeType,
-      type: i2lNodeType,
-      image: image_name ? { image_name } : undefined,
-      ...(i2lNodeType === 'i2l' ? { fp32 } : {}),
-    });
+    i2l.image = { image_name };
 
     const resizeImageToOriginalSize = g.addNode({
       type: 'img_resize',
@@ -76,12 +69,7 @@ export const addImageToImage = async ({
     return resizeImageToOriginalSize;
   } else {
     // No need to resize, just decode
-    const i2l = g.addNode({
-      id: i2lNodeType,
-      type: i2lNodeType,
-      image: image_name ? { image_name } : undefined,
-      ...(i2lNodeType === 'i2l' ? { fp32 } : {}),
-    });
+    i2l.image = { image_name };
     g.addEdge(vaeSource, 'vae', i2l, 'vae');
     g.addEdge(i2l, 'latents', denoise, 'latents');
     return l2i;

invokeai/frontend/web/src/features/nodes/util/graph/generation/addInpaint.ts

@@ -21,15 +21,14 @@ type AddInpaintArg = {
   g: Graph;
   manager: CanvasManager;
   l2i: Invocation<LatentToImageNodes>;
-  i2lNodeType: 'i2l' | 'flux_vae_encode' | 'sd3_i2l' | 'cogview4_i2l';
+  i2l: Invocation<'i2l' | 'flux_vae_encode' | 'sd3_i2l' | 'cogview4_i2l'>;
   denoise: Invocation<DenoiseLatentsNodes>;
   vaeSource: Invocation<VaeSourceNodes | MainModelLoaderNodes>;
   modelLoader: Invocation<MainModelLoaderNodes>;
   originalSize: Dimensions;
   scaledSize: Dimensions;
   denoising_start: number;
-  fp32: boolean;
-  seed: number;
+  seed: Invocation<'integer'>;
 };
 
 export const addInpaint = async ({
@@ -37,14 +36,13 @@ export const addInpaint = async ({
   g,
   manager,
   l2i,
-  i2lNodeType,
+  i2l,
   denoise,
   vaeSource,
   modelLoader,
   originalSize,
   scaledSize,
   denoising_start,
-  fp32,
   seed,
 }: AddInpaintArg): Promise<Invocation<'invokeai_img_blend' | 'apply_mask_to_image'>> => {
   denoise.denoising_start = denoising_start;
@@ -97,12 +95,7 @@ export const addInpaint = async ({
 
   if (needsScaleBeforeProcessing) {
     // Scale before processing requires some resizing
-    const i2l = g.addNode({
-      id: i2lNodeType,
-      type: i2lNodeType,
-      image: initialImage.image_name ? { image_name: initialImage.image_name } : undefined,
-      ...(i2lNodeType === 'i2l' ? { fp32 } : {}),
-    });
+    i2l.image = { image_name: initialImage.image_name };
 
     const resizeImageToScaledSize = g.addNode({
       type: 'img_resize',
@@ -128,9 +121,9 @@ export const addInpaint = async ({
         noise_type: 'gaussian',
         amount: 1.0, // the mask controls the actual intensity
         noise_color: true,
-        seed: seed,
       });
 
+      g.addEdge(seed, 'value', noiseNode, 'seed');
       g.addEdge(resizeImageToScaledSize, 'image', noiseNode, 'image');
       g.addEdge(resizeNoiseMaskToScaledSize, 'image', noiseNode, 'mask');
       g.addEdge(noiseNode, 'image', i2l, 'image');
@@ -160,7 +153,7 @@ export const addInpaint = async ({
       coherence_mode: params.canvasCoherenceMode,
       minimum_denoise: params.canvasCoherenceMinDenoise,
       edge_radius: params.canvasCoherenceEdgeSize,
-      fp32,
+      fp32: i2l.type === 'i2l' ? i2l.fp32 : false,
     });
     const expandMask = g.addNode({
       type: 'expand_mask_with_fade',
@@ -208,12 +201,7 @@ export const addInpaint = async ({
     }
   } else {
     // No scale before processing, much simpler
-    const i2l = g.addNode({
-      id: i2lNodeType,
-      type: i2lNodeType,
-      image: initialImage.image_name ? { image_name: initialImage.image_name } : undefined,
-      ...(i2lNodeType === 'i2l' ? { fp32 } : {}),
-    });
+    i2l.image = { image_name: initialImage.image_name };
 
     // If we have a noise mask, apply it to the input image before i2l conversion
     if (noiseMaskImage) {
@@ -221,14 +209,18 @@ export const addInpaint = async ({
       const noiseNode = g.addNode({
         type: 'img_noise',
         id: getPrefixedId('add_inpaint_noise'),
-        image: initialImage.image_name ? { image_name: initialImage.image_name } : undefined,
+        image: {
+          image_name: initialImage.image_name,
+        },
         noise_type: 'gaussian',
         amount: 1.0, // the mask controls the actual intensity
         noise_color: true,
-        seed: seed,
-        mask: { image_name: noiseMaskImage.image_name },
+        mask: {
+          image_name: noiseMaskImage.image_name,
+        },
       });
 
+      g.addEdge(seed, 'value', noiseNode, 'seed');
       g.addEdge(noiseNode, 'image', i2l, 'image');
     }
 
@@ -238,7 +230,7 @@ export const addInpaint = async ({
       coherence_mode: params.canvasCoherenceMode,
       minimum_denoise: params.canvasCoherenceMinDenoise,
       edge_radius: params.canvasCoherenceEdgeSize,
-      fp32,
+      fp32: i2l.type === 'i2l' ? i2l.fp32 : false,
       image: { image_name: initialImage.image_name },
       mask: { image_name: maskImage.image_name },
     });

invokeai/frontend/web/src/features/nodes/util/graph/generation/addOutpaint.ts

@@ -22,15 +22,14 @@ type AddOutpaintArg = {
   g: Graph;
   manager: CanvasManager;
   l2i: Invocation<LatentToImageNodes>;
-  i2lNodeType: ImageToLatentsNodes;
+  i2l: Invocation<ImageToLatentsNodes>;
   denoise: Invocation<DenoiseLatentsNodes>;
   vaeSource: Invocation<VaeSourceNodes | MainModelLoaderNodes>;
   modelLoader: Invocation<MainModelLoaderNodes>;
   originalSize: Dimensions;
   scaledSize: Dimensions;
   denoising_start: number;
-  fp32: boolean;
-  seed: number;
+  seed: Invocation<'integer'>;
 };
 
 export const addOutpaint = async ({
@@ -38,14 +37,13 @@ export const addOutpaint = async ({
   g,
   manager,
   l2i,
-  i2lNodeType,
+  i2l,
   denoise,
   vaeSource,
   modelLoader,
   originalSize,
   scaledSize,
   denoising_start,
-  fp32,
   seed,
 }: AddOutpaintArg): Promise<Invocation<'invokeai_img_blend' | 'apply_mask_to_image'>> => {
   denoise.denoising_start = denoising_start;
@@ -138,7 +136,7 @@ export const addOutpaint = async ({
       coherence_mode: params.canvasCoherenceMode,
       minimum_denoise: params.canvasCoherenceMinDenoise,
       edge_radius: params.canvasCoherenceEdgeSize,
-      fp32,
+      fp32: i2l.type === 'i2l' ? i2l.fp32 : false,
     });
     g.addEdge(infill, 'image', createGradientMask, 'image');
     g.addEdge(resizeInputMaskToScaledSize, 'image', createGradientMask, 'mask');
@@ -149,13 +147,6 @@ export const addOutpaint = async ({
 
     g.addEdge(createGradientMask, 'denoise_mask', denoise, 'denoise_mask');
 
-    // Decode infilled image and connect to denoise
-    const i2l = g.addNode({
-      id: i2lNodeType,
-      type: i2lNodeType,
-      ...(i2lNodeType === 'i2l' ? { fp32 } : {}),
-    });
-
     // If we have a noise mask, apply it to the input image before i2l conversion
     if (noiseMaskImage) {
       // Resize the noise mask to match the scaled size
@@ -173,9 +164,9 @@ export const addOutpaint = async ({
         noise_type: 'gaussian',
         amount: 1.0, // the mask controls the actual intensity
         noise_color: true,
-        seed: seed,
       });
 
+      g.addEdge(seed, 'value', noiseNode, 'seed');
       g.addEdge(resizeNoiseMaskToScaledSize, 'image', noiseNode, 'mask');
       g.addEdge(infill, 'image', noiseNode, 'image');
       g.addEdge(noiseNode, 'image', i2l, 'image');
@@ -232,11 +223,6 @@ export const addOutpaint = async ({
   } else {
     infill.image = { image_name: initialImage.image_name };
     // No scale before processing, much simpler
-    const i2l = g.addNode({
-      id: i2lNodeType,
-      type: i2lNodeType,
-      ...(i2lNodeType === 'i2l' ? { fp32 } : {}),
-    });
     const initialImageAlphaToMask = g.addNode({
       id: getPrefixedId('image_alpha_to_mask'),
       type: 'tomask',
@@ -253,7 +239,7 @@ export const addOutpaint = async ({
       coherence_mode: params.canvasCoherenceMode,
       minimum_denoise: params.canvasCoherenceMinDenoise,
       edge_radius: params.canvasCoherenceEdgeSize,
-      fp32,
+      fp32: i2l.type === 'i2l' ? i2l.fp32 : false,
       image: { image_name: initialImage.image_name },
     });
     g.addEdge(initialImageAlphaToMask, 'image', maskCombine, 'mask2');
@@ -269,10 +255,10 @@ export const addOutpaint = async ({
         noise_type: 'gaussian',
         amount: 1.0, // the mask controls the actual intensity
         noise_color: true,
-        seed: seed,
         mask: { image_name: noiseMaskImage.image_name },
       });
 
+      g.addEdge(seed, 'value', noiseNode, 'seed');
       g.addEdge(infill, 'image', noiseNode, 'image');
       g.addEdge(noiseNode, 'image', i2l, 'image');
     } else {

invokeai/frontend/web/src/features/nodes/util/graph/generation/buildCogView4Graph.ts

@@ -32,7 +32,7 @@ export const buildCogView4Graph = async (arg: GraphBuilderArg): Promise<GraphBui
 
   const { bbox } = canvas;
 
-  const { model, cfgScale: cfg_scale, seed, steps } = params;
+  const { model, cfgScale: cfg_scale, seed: _seed, steps } = params;
 
   assert(model, 'No model found in state');
 
@@ -40,6 +40,11 @@ export const buildCogView4Graph = async (arg: GraphBuilderArg): Promise<GraphBui
   const { positivePrompt, negativePrompt } = selectPresetModifiedPrompts(state);
 
   const g = new Graph(getPrefixedId('cogview4_graph'));
+  const seed = g.addNode({
+    id: getPrefixedId('seed'),
+    type: 'integer',
+    value: _seed,
+  });
   const modelLoader = g.addNode({
     type: 'cogview4_model_loader',
     id: getPrefixedId('cogview4_model_loader'),
@@ -71,7 +76,12 @@ export const buildCogView4Graph = async (arg: GraphBuilderArg): Promise<GraphBui
     type: 'cogview4_l2i',
     id: getPrefixedId('l2i'),
   });
+  const i2l = g.addNode({
+    type: 'cogview4_i2l',
+    id: getPrefixedId('cogview4_i2l'),
+  });
 
+  g.addEdge(seed, 'value', denoise, 'seed');
   g.addEdge(modelLoader, 'transformer', denoise, 'transformer');
   g.addEdge(modelLoader, 'glm_encoder', posCond, 'glm_encoder');
   g.addEdge(modelLoader, 'glm_encoder', negCond, 'glm_encoder');
@@ -92,7 +102,6 @@ export const buildCogView4Graph = async (arg: GraphBuilderArg): Promise<GraphBui
     positive_prompt: positivePrompt,
     negative_prompt: negativePrompt,
     model: Graph.getModelMetadataField(modelConfig),
-    seed,
     steps,
   });
 
@@ -109,14 +118,13 @@ export const buildCogView4Graph = async (arg: GraphBuilderArg): Promise<GraphBui
       g,
       manager,
       l2i,
-      i2lNodeType: 'cogview4_i2l',
+      i2l,
       denoise,
       vaeSource: modelLoader,
       originalSize,
       scaledSize,
       bbox,
       denoising_start,
-      fp32: false,
     });
     g.upsertMetadata({ generation_mode: 'cogview4_img2img' });
   } else if (generationMode === 'inpaint') {
@@ -126,14 +134,13 @@ export const buildCogView4Graph = async (arg: GraphBuilderArg): Promise<GraphBui
       g,
       manager,
       l2i,
-      i2lNodeType: 'cogview4_i2l',
+      i2l,
       denoise,
       vaeSource: modelLoader,
       modelLoader,
       originalSize,
       scaledSize,
       denoising_start,
-      fp32: false,
       seed,
     });
     g.upsertMetadata({ generation_mode: 'cogview4_inpaint' });
@@ -144,14 +151,13 @@ export const buildCogView4Graph = async (arg: GraphBuilderArg): Promise<GraphBui
       g,
       manager,
       l2i,
-      i2lNodeType: 'cogview4_i2l',
+      i2l,
       denoise,
       vaeSource: modelLoader,
       modelLoader,
       originalSize,
       scaledSize,
       denoising_start,
-      fp32: false,
       seed,
     });
     g.upsertMetadata({ generation_mode: 'cogview4_outpaint' });
@@ -174,7 +180,7 @@ export const buildCogView4Graph = async (arg: GraphBuilderArg): Promise<GraphBui
   g.setMetadataReceivingNode(canvasOutput);
   return {
     g,
-    seedFieldIdentifier: { nodeId: denoise.id, fieldName: 'seed' },
+    seedFieldIdentifier: { nodeId: seed.id, fieldName: 'value' },
     positivePromptFieldIdentifier: { nodeId: posCond.id, fieldName: 'prompt' },
   };
 };

invokeai/frontend/web/src/features/nodes/util/graph/generation/buildFLUXGraph.ts

@@ -49,7 +49,7 @@ export const buildFLUXGraph = async (arg: GraphBuilderArg): Promise<GraphBuilder
 
   const {
     guidance: baseGuidance,
-    seed,
+    seed: _seed,
     steps,
     fluxVAE,
     t5EncoderModel,
@@ -101,6 +101,11 @@ export const buildFLUXGraph = async (arg: GraphBuilderArg): Promise<GraphBuilder
   const { positivePrompt } = selectPresetModifiedPrompts(state);
 
   const g = new Graph(getPrefixedId('flux_graph'));
+  const seed = g.addNode({
+    id: getPrefixedId('seed'),
+    type: 'integer',
+    value: _seed,
+  });
   const modelLoader = g.addNode({
     type: 'flux_model_loader',
     id: getPrefixedId('flux_model_loader'),
@@ -125,7 +130,6 @@ export const buildFLUXGraph = async (arg: GraphBuilderArg): Promise<GraphBuilder
     id: getPrefixedId('flux_denoise'),
     guidance,
     num_steps: steps,
-    seed,
     denoising_start: 0,
     denoising_end: 1,
     width: scaledSize.width,
@@ -136,6 +140,10 @@ export const buildFLUXGraph = async (arg: GraphBuilderArg): Promise<GraphBuilder
     type: 'flux_vae_decode',
     id: getPrefixedId('flux_vae_decode'),
   });
+  const i2l = g.addNode({
+    type: 'flux_vae_encode',
+    id: getPrefixedId('flux_vae_encode'),
+  });
 
   if (isFluxKontextDev) {
     const validFLUXKontextConfigs = selectRefImagesSlice(state)
@@ -162,6 +170,7 @@ export const buildFLUXGraph = async (arg: GraphBuilderArg): Promise<GraphBuilder
     }
   }
 
+  g.addEdge(seed, 'value', denoise, 'seed');
   g.addEdge(modelLoader, 'transformer', denoise, 'transformer');
   g.addEdge(modelLoader, 'vae', denoise, 'controlnet_vae');
   g.addEdge(modelLoader, 'vae', l2i, 'vae');
@@ -181,7 +190,6 @@ export const buildFLUXGraph = async (arg: GraphBuilderArg): Promise<GraphBuilder
     height: originalSize.height,
     positive_prompt: positivePrompt,
     model: Graph.getModelMetadataField(model),
-    seed,
     steps,
     vae: fluxVAE,
     t5_encoder: t5EncoderModel,
@@ -220,14 +228,13 @@ export const buildFLUXGraph = async (arg: GraphBuilderArg): Promise<GraphBuilder
       g,
       manager,
       l2i,
-      i2lNodeType: 'flux_vae_encode',
+      i2l,
       denoise,
       vaeSource: modelLoader,
       originalSize,
       scaledSize,
       bbox,
       denoising_start,
-      fp32: false,
     });
     g.upsertMetadata({ generation_mode: 'flux_img2img' });
   } else if (generationMode === 'inpaint') {
@@ -237,14 +244,13 @@ export const buildFLUXGraph = async (arg: GraphBuilderArg): Promise<GraphBuilder
       g,
       manager,
       l2i,
-      i2lNodeType: 'flux_vae_encode',
+      i2l,
       denoise,
       vaeSource: modelLoader,
       modelLoader,
       originalSize,
       scaledSize,
       denoising_start,
-      fp32: false,
       seed,
     });
     g.upsertMetadata({ generation_mode: 'flux_inpaint' });
@@ -255,14 +261,13 @@ export const buildFLUXGraph = async (arg: GraphBuilderArg): Promise<GraphBuilder
       g,
       manager,
       l2i,
-      i2lNodeType: 'flux_vae_encode',
+      i2l,
       denoise,
       vaeSource: modelLoader,
       modelLoader,
       originalSize,
       scaledSize,
       denoising_start,
-      fp32: false,
       seed,
     });
     g.upsertMetadata({ generation_mode: 'flux_outpaint' });
@@ -372,7 +377,7 @@ export const buildFLUXGraph = async (arg: GraphBuilderArg): Promise<GraphBuilder
   g.setMetadataReceivingNode(canvasOutput);
   return {
     g,
-    seedFieldIdentifier: { nodeId: denoise.id, fieldName: 'seed' },
+    seedFieldIdentifier: { nodeId: seed.id, fieldName: 'value' },
     positivePromptFieldIdentifier: { nodeId: posCond.id, fieldName: 'prompt' },
   };
 };

invokeai/frontend/web/src/features/nodes/util/graph/generation/buildSD1Graph.ts

@@ -48,7 +48,7 @@ export const buildSD1Graph = async (arg: GraphBuilderArg): Promise<GraphBuilderR
     clipSkip: skipped_layers,
     shouldUseCpuNoise,
     vaePrecision,
-    seed,
+    seed: _seed,
     vae,
   } = params;
 
@@ -59,6 +59,11 @@ export const buildSD1Graph = async (arg: GraphBuilderArg): Promise<GraphBuilderR
   const { originalSize, scaledSize } = selectOriginalAndScaledSizes(state);
 
   const g = new Graph(getPrefixedId('sd1_graph'));
+  const seed = g.addNode({
+    id: getPrefixedId('seed'),
+    type: 'integer',
+    value: _seed,
+  });
   const modelLoader = g.addNode({
     type: 'main_model_loader',
     id: getPrefixedId('sd1_model_loader'),
@@ -90,7 +95,6 @@ export const buildSD1Graph = async (arg: GraphBuilderArg): Promise<GraphBuilderR
   const noise = g.addNode({
     type: 'noise',
     id: getPrefixedId('noise'),
-    seed,
     width: scaledSize.width,
     height: scaledSize.height,
     use_cpu: shouldUseCpuNoise,
@@ -110,6 +114,11 @@ export const buildSD1Graph = async (arg: GraphBuilderArg): Promise<GraphBuilderR
     id: getPrefixedId('l2i'),
     fp32,
   });
+  const i2l = g.addNode({
+    type: 'i2l',
+    id: getPrefixedId('i2l'),
+    fp32,
+  });
   const vaeLoader =
     vae?.base === model.base
       ? g.addNode({
@@ -119,6 +128,7 @@ export const buildSD1Graph = async (arg: GraphBuilderArg): Promise<GraphBuilderR
         })
       : null;
 
+  g.addEdge(seed, 'value', noise, 'seed');
   g.addEdge(modelLoader, 'unet', denoise, 'unet');
   g.addEdge(modelLoader, 'clip', clipSkip, 'clip');
   g.addEdge(clipSkip, 'clip', posCond, 'clip');
@@ -140,7 +150,6 @@ export const buildSD1Graph = async (arg: GraphBuilderArg): Promise<GraphBuilderR
     positive_prompt: positivePrompt,
     negative_prompt: negativePrompt,
     model: Graph.getModelMetadataField(model),
-    seed,
     steps,
     rand_device: shouldUseCpuNoise ? 'cpu' : 'cuda',
     scheduler,
@@ -171,14 +180,13 @@ export const buildSD1Graph = async (arg: GraphBuilderArg): Promise<GraphBuilderR
       g,
       manager,
       l2i,
-      i2lNodeType: 'i2l',
+      i2l,
       denoise,
       vaeSource,
       originalSize,
       scaledSize,
       bbox,
       denoising_start,
-      fp32: vaePrecision === 'fp32',
     });
     g.upsertMetadata({ generation_mode: 'img2img' });
   } else if (generationMode === 'inpaint') {
@@ -188,14 +196,13 @@ export const buildSD1Graph = async (arg: GraphBuilderArg): Promise<GraphBuilderR
       g,
       manager,
       l2i,
-      i2lNodeType: 'i2l',
+      i2l,
       denoise,
       vaeSource,
       modelLoader,
       originalSize,
       scaledSize,
       denoising_start,
-      fp32: vaePrecision === 'fp32',
       seed,
     });
     g.upsertMetadata({ generation_mode: 'inpaint' });
@@ -206,14 +213,13 @@ export const buildSD1Graph = async (arg: GraphBuilderArg): Promise<GraphBuilderR
       g,
       manager,
       l2i,
-      i2lNodeType: 'i2l',
+      i2l,
       denoise,
       vaeSource,
       modelLoader,
       originalSize,
       scaledSize,
       denoising_start,
-      fp32,
       seed,
     });
     g.upsertMetadata({ generation_mode: 'outpaint' });
@@ -310,7 +316,7 @@ export const buildSD1Graph = async (arg: GraphBuilderArg): Promise<GraphBuilderR
   g.setMetadataReceivingNode(canvasOutput);
   return {
     g,
-    seedFieldIdentifier: { nodeId: noise.id, fieldName: 'seed' },
+    seedFieldIdentifier: { nodeId: seed.id, fieldName: 'value' },
     positivePromptFieldIdentifier: { nodeId: posCond.id, fieldName: 'prompt' },
   };
 };

invokeai/frontend/web/src/features/nodes/util/graph/generation/buildSD3Graph.ts

@@ -36,7 +36,7 @@ export const buildSD3Graph = async (arg: GraphBuilderArg): Promise<GraphBuilderR
 
   const {
     cfgScale: cfg_scale,
-    seed,
+    seed: _seed,
     steps,
     vae,
     t5EncoderModel,
@@ -50,6 +50,11 @@ export const buildSD3Graph = async (arg: GraphBuilderArg): Promise<GraphBuilderR
   const { positivePrompt, negativePrompt } = selectPresetModifiedPrompts(state);
 
   const g = new Graph(getPrefixedId('sd3_graph'));
+  const seed = g.addNode({
+    id: getPrefixedId('seed'),
+    type: 'integer',
+    value: _seed,
+  });
   const modelLoader = g.addNode({
     type: 'sd3_model_loader',
     id: getPrefixedId('sd3_model_loader'),
@@ -85,7 +90,12 @@ export const buildSD3Graph = async (arg: GraphBuilderArg): Promise<GraphBuilderR
     type: 'sd3_l2i',
     id: getPrefixedId('l2i'),
   });
+  const i2l = g.addNode({
+    type: 'sd3_i2l',
+    id: getPrefixedId('sd3_i2l'),
+  });
 
+  g.addEdge(seed, 'value', denoise, 'seed');
   g.addEdge(modelLoader, 'transformer', denoise, 'transformer');
   g.addEdge(modelLoader, 'clip_l', posCond, 'clip_l');
   g.addEdge(modelLoader, 'clip_l', negCond, 'clip_l');
@@ -106,7 +116,6 @@ export const buildSD3Graph = async (arg: GraphBuilderArg): Promise<GraphBuilderR
     positive_prompt: positivePrompt,
     negative_prompt: negativePrompt,
     model: Graph.getModelMetadataField(model),
-    seed,
     steps,
     vae: vae ?? undefined,
   });
@@ -133,14 +142,13 @@ export const buildSD3Graph = async (arg: GraphBuilderArg): Promise<GraphBuilderR
       g,
       manager,
       l2i,
-      i2lNodeType: 'sd3_i2l',
+      i2l,
       denoise,
       vaeSource: modelLoader,
       originalSize,
       scaledSize,
       bbox,
       denoising_start,
-      fp32: false,
     });
     g.upsertMetadata({ generation_mode: 'sd3_img2img' });
   } else if (generationMode === 'inpaint') {
@@ -150,14 +158,13 @@ export const buildSD3Graph = async (arg: GraphBuilderArg): Promise<GraphBuilderR
       g,
       manager,
       l2i,
-      i2lNodeType: 'sd3_i2l',
+      i2l,
       denoise,
       vaeSource: modelLoader,
       modelLoader,
       originalSize,
       scaledSize,
       denoising_start,
-      fp32: false,
       seed,
     });
     g.upsertMetadata({ generation_mode: 'sd3_inpaint' });
@@ -168,14 +175,13 @@ export const buildSD3Graph = async (arg: GraphBuilderArg): Promise<GraphBuilderR
       g,
       manager,
       l2i,
-      i2lNodeType: 'sd3_i2l',
+      i2l,
       denoise,
       vaeSource: modelLoader,
       modelLoader,
       originalSize,
       scaledSize,
       denoising_start,
-      fp32: false,
       seed,
     });
     g.upsertMetadata({ generation_mode: 'sd3_outpaint' });
@@ -198,7 +204,7 @@ export const buildSD3Graph = async (arg: GraphBuilderArg): Promise<GraphBuilderR
   g.setMetadataReceivingNode(canvasOutput);
   return {
     g,
-    seedFieldIdentifier: { nodeId: denoise.id, fieldName: 'seed' },
+    seedFieldIdentifier: { nodeId: seed.id, fieldName: 'value' },
     positivePromptFieldIdentifier: { nodeId: posCond.id, fieldName: 'prompt' },
   };
 };

invokeai/frontend/web/src/features/nodes/util/graph/generation/buildSDXLGraph.ts

@@ -47,7 +47,7 @@ export const buildSDXLGraph = async (arg: GraphBuilderArg): Promise<GraphBuilder
     cfgScale: cfg_scale,
     cfgRescaleMultiplier: cfg_rescale_multiplier,
     scheduler,
-    seed,
+    seed: _seed,
     steps,
     shouldUseCpuNoise,
     vaePrecision,
@@ -64,6 +64,11 @@ export const buildSDXLGraph = async (arg: GraphBuilderArg): Promise<GraphBuilder
     selectPresetModifiedPrompts(state);
 
   const g = new Graph(getPrefixedId('sdxl_graph'));
+  const seed = g.addNode({
+    id: getPrefixedId('seed'),
+    type: 'integer',
+    value: _seed,
+  });
   const modelLoader = g.addNode({
     type: 'sdxl_model_loader',
     id: getPrefixedId('sdxl_model_loader'),
@@ -92,7 +97,6 @@ export const buildSDXLGraph = async (arg: GraphBuilderArg): Promise<GraphBuilder
   const noise = g.addNode({
     type: 'noise',
     id: getPrefixedId('noise'),
-    seed,
     width: scaledSize.width,
     height: scaledSize.height,
     use_cpu: shouldUseCpuNoise,
@@ -112,6 +116,11 @@ export const buildSDXLGraph = async (arg: GraphBuilderArg): Promise<GraphBuilder
     id: getPrefixedId('l2i'),
     fp32,
   });
+  const i2l = g.addNode({
+    type: 'i2l',
+    id: getPrefixedId('i2l'),
+    fp32,
+  });
   const vaeLoader =
     vae?.base === model.base
       ? g.addNode({
@@ -121,6 +130,7 @@ export const buildSDXLGraph = async (arg: GraphBuilderArg): Promise<GraphBuilder
         })
       : null;
 
+  g.addEdge(seed, 'value', noise, 'seed');
   g.addEdge(modelLoader, 'unet', denoise, 'unet');
   g.addEdge(modelLoader, 'clip', posCond, 'clip');
   g.addEdge(modelLoader, 'clip', negCond, 'clip');
@@ -141,7 +151,6 @@ export const buildSDXLGraph = async (arg: GraphBuilderArg): Promise<GraphBuilder
     positive_prompt: positivePrompt,
     negative_prompt: negativePrompt,
     model: Graph.getModelMetadataField(model),
-    seed,
     steps,
     rand_device: shouldUseCpuNoise ? 'cpu' : 'cuda',
     scheduler,
@@ -178,14 +187,13 @@ export const buildSDXLGraph = async (arg: GraphBuilderArg): Promise<GraphBuilder
       g,
       manager,
       l2i,
-      i2lNodeType: 'i2l',
+      i2l,
       denoise,
       vaeSource,
       originalSize,
       scaledSize,
       bbox,
       denoising_start,
-      fp32,
     });
     g.upsertMetadata({ generation_mode: 'sdxl_img2img' });
   } else if (generationMode === 'inpaint') {
@@ -195,14 +203,13 @@ export const buildSDXLGraph = async (arg: GraphBuilderArg): Promise<GraphBuilder
       g,
       manager,
       l2i,
-      i2lNodeType: 'i2l',
+      i2l,
       denoise,
       vaeSource,
       modelLoader,
       originalSize,
       scaledSize,
       denoising_start,
-      fp32,
       seed,
     });
     g.upsertMetadata({ generation_mode: 'sdxl_inpaint' });
@@ -213,14 +220,13 @@ export const buildSDXLGraph = async (arg: GraphBuilderArg): Promise<GraphBuilder
       g,
       manager,
       l2i,
-      i2lNodeType: 'i2l',
+      i2l,
       denoise,
       vaeSource,
       modelLoader,
       originalSize,
       scaledSize,
       denoising_start,
-      fp32,
       seed,
     });
     g.upsertMetadata({ generation_mode: 'sdxl_outpaint' });
@@ -316,7 +322,7 @@ export const buildSDXLGraph = async (arg: GraphBuilderArg): Promise<GraphBuilder
   g.setMetadataReceivingNode(canvasOutput);
   return {
     g,
-    seedFieldIdentifier: { nodeId: noise.id, fieldName: 'seed' },
+    seedFieldIdentifier: { nodeId: seed.id, fieldName: 'value' },
     positivePromptFieldIdentifier: { nodeId: posCond.id, fieldName: 'prompt' },
   };
 };