chore(frontend): add regression test for qwen image CFG handling in graph builder

chore(backend): add test for heuristic detection of Qwen Image Edit GGUF model variant

chore(frontend): add regression test for ref images not added to qwen image in generate mode

fix(frontend): graph build handling of Qwen Image when CFG <=1

chore(frontend): add regression test for optimal dimension selection

Author: lstein

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

@@ -1,8 +1,153 @@
-import { describe, expect, it } from 'vitest';
+import { afterEach, describe, expect, it, vi } from 'vitest';
 
-import { isQwenImageEditModel } from './buildQwenImageGraph';
+vi.mock('app/logging/logger', () => ({
+  logger: () => ({
+    debug: vi.fn(),
+  }),
+}));
+
+let nextId = 0;
+vi.mock('features/controlLayers/konva/util', () => ({
+  getPrefixedId: (prefix: string) => `${prefix}:${nextId++}`,
+}));
+
+const model = {
+  key: 'qwen-model',
+  hash: 'qwen-hash',
+  name: 'Qwen Image Generate',
+  base: 'qwen-image',
+  type: 'main',
+  variant: 'generate',
+};
+
+const defaultParams: {
+  cfgScale: number | number[];
+  steps: number;
+  qwenImageComponentSource: null;
+  qwenImageQuantization: string;
+  qwenImageShift: number;
+} = {
+  cfgScale: 4,
+  steps: 20,
+  qwenImageComponentSource: null,
+  qwenImageQuantization: 'none',
+  qwenImageShift: 1,
+};
+
+let params = { ...defaultParams };
+
+const refImagesSlice = {
+  entities: [
+    {
+      id: 'ref-image-1',
+      isEnabled: true,
+      config: {
+        type: 'qwen_image_reference_image',
+        image: {
+          original: {
+            image: {
+              image_name: 'reference.png',
+              width: 512,
+              height: 512,
+            },
+          },
+        },
+      },
+    },
+  ],
+};
+
+vi.mock('features/controlLayers/store/paramsSlice', () => ({
+  selectMainModelConfig: vi.fn(() => model),
+  selectParamsSlice: vi.fn(() => params),
+}));
+
+vi.mock('features/controlLayers/store/refImagesSlice', () => ({
+  selectRefImagesSlice: vi.fn(() => refImagesSlice),
+}));
+
+vi.mock('features/controlLayers/store/selectors', () => ({
+  selectCanvasMetadata: vi.fn(() => ({})),
+}));
+
+vi.mock('features/controlLayers/store/types', () => ({
+  isQwenImageReferenceImageConfig: vi.fn((config: { type?: string }) => config.type === 'qwen_image_reference_image'),
+}));
+
+vi.mock('features/controlLayers/store/validators', () => ({
+  getGlobalReferenceImageWarnings: vi.fn(() => []),
+}));
+
+vi.mock('features/metadata/util/modelFetchingHelpers', () => ({
+  fetchModelConfigWithTypeGuard: vi.fn(() => Promise.resolve(model)),
+}));
+
+vi.mock('features/nodes/types/common', async () => {
+  const actual = await vi.importActual('features/nodes/types/common');
+  return {
+    ...actual,
+    zImageField: {
+      parse: vi.fn((image) => image),
+    },
+  };
+});
+
+vi.mock('features/nodes/util/graph/generation/addImageToImage', () => ({
+  addImageToImage: vi.fn(),
+}));
+
+vi.mock('features/nodes/util/graph/generation/addInpaint', () => ({
+  addInpaint: vi.fn(),
+}));
+
+vi.mock('features/nodes/util/graph/generation/addNSFWChecker', () => ({
+  addNSFWChecker: vi.fn((_g, node) => node),
+}));
+
+vi.mock('features/nodes/util/graph/generation/addOutpaint', () => ({
+  addOutpaint: vi.fn(),
+}));
+
+vi.mock('features/nodes/util/graph/generation/addQwenImageLoRAs', () => ({
+  addQwenImageLoRAs: vi.fn(),
+}));
+
+vi.mock('features/nodes/util/graph/generation/addTextToImage', () => ({
+  addTextToImage: vi.fn(({ l2i }) => l2i),
+}));
+
+vi.mock('features/nodes/util/graph/generation/addWatermarker', () => ({
+  addWatermarker: vi.fn((_g, node) => node),
+}));
+
+vi.mock('features/nodes/util/graph/graphBuilderUtils', () => ({
+  selectCanvasOutputFields: vi.fn(() => ({})),
+  selectPresetModifiedPrompts: vi.fn(() => ({
+    positive: 'a prompt',
+    negative: 'a negative prompt',
+  })),
+}));
+
+vi.mock('features/ui/store/uiSelectors', () => ({
+  selectActiveTab: vi.fn(() => 'generation'),
+}));
+
+vi.mock('services/api/types', async () => {
+  const actual = await vi.importActual('services/api/types');
+  return {
+    ...actual,
+    isNonRefinerMainModelConfig: vi.fn(() => true),
+  };
+});
+
+import { buildQwenImageGraph, isQwenImageEditModel, shouldUseCfg } from './buildQwenImageGraph';
 
 describe('isQwenImageEditModel', () => {
+  afterEach(() => {
+    nextId = 0;
+    params = { ...defaultParams };
+  });
+
   it('returns true for edit variant', () => {
     expect(isQwenImageEditModel({ variant: 'edit' })).toBe(true);
   });
@@ -35,23 +180,163 @@ describe('isQwenImageEditModel', () => {
 
   describe('reference image filtering regression', () => {
     it('prevents reference images from leaking to generate models when switching from edit', () => {
-      // Simulate: user was using an edit model (variant='edit') with reference images,
-      // then switches to a generate model (variant='generate').
-      // The generate model should NOT receive reference images.
       const editModel = { variant: 'edit' as const };
       const generateModel = { variant: 'generate' as const };
 
-      // Edit model: reference images should be collected
       expect(isQwenImageEditModel(editModel)).toBe(true);
-
-      // Generate model: reference images must NOT be collected, even if they exist in state
       expect(isQwenImageEditModel(generateModel)).toBe(false);
     });
 
     it('prevents reference images from leaking to GGUF models without variant', () => {
-      // GGUF models installed without a variant field default to generate behavior
       const ggufModelNoVariant = {};
       expect(isQwenImageEditModel(ggufModelNoVariant)).toBe(false);
     });
   });
 });
+
+describe('shouldUseCfg', () => {
+  afterEach(() => {
+    nextId = 0;
+    params = { ...defaultParams };
+  });
+
+  describe('negative conditioning is included when cfgScale > 1', () => {
+    it('returns true for cfgScale = 4', () => {
+      expect(shouldUseCfg(4)).toBe(true);
+    });
+
+    it('returns true for cfgScale = 1.5', () => {
+      expect(shouldUseCfg(1.5)).toBe(true);
+    });
+
+    it('returns true for cfgScale = 1.01', () => {
+      expect(shouldUseCfg(1.01)).toBe(true);
+    });
+  });
+
+  describe('negative conditioning is excluded when cfgScale <= 1', () => {
+    it('returns false for cfgScale = 1', () => {
+      expect(shouldUseCfg(1)).toBe(false);
+    });
+
+    it('returns false for cfgScale = 0.5', () => {
+      expect(shouldUseCfg(0.5)).toBe(false);
+    });
+
+    it('returns false for cfgScale = 0', () => {
+      expect(shouldUseCfg(0)).toBe(false);
+    });
+  });
+
+  describe('array cfgScale (per-step)', () => {
+    it('returns true for per-step arrays with values > 1', () => {
+      expect(shouldUseCfg([4, 3, 2, 1])).toBe(true);
+    });
+
+    it('returns true when any per-step cfg value is > 1', () => {
+      expect(shouldUseCfg([1, 1.1, 1])).toBe(true);
+      expect(shouldUseCfg([0.5, 2, 0.5])).toBe(true);
+    });
+
+    it('returns false when every per-step cfg value is <= 1', () => {
+      expect(shouldUseCfg([1, 1, 1])).toBe(false);
+      expect(shouldUseCfg([0.5, 0.75, 1])).toBe(false);
+    });
+  });
+
+  describe('CFG gating regression', () => {
+    it('with cfgScale=1, neg_prompt is absent from the graph (no wasted compute)', () => {
+      expect(shouldUseCfg(1)).toBe(false);
+    });
+
+    it('with cfgScale=4, neg_prompt is present in the graph for classifier-free guidance', () => {
+      expect(shouldUseCfg(4)).toBe(true);
+    });
+
+    it('omits negative conditioning edges from the graph when per-step cfg never exceeds 1', async () => {
+      params = {
+        ...defaultParams,
+        cfgScale: [1, 1, 1],
+      };
+
+      const { g } = await buildQwenImageGraph({
+        generationMode: 'txt2img',
+        manager: null,
+        state: {
+          system: {
+            shouldUseNSFWChecker: false,
+            shouldUseWatermarker: false,
+          },
+        } as never,
+      });
+
+      const graph = g.getGraph();
+      const nodeIds = Object.keys(graph.nodes);
+      const hasNegativePromptNode = nodeIds.some((id) => id.startsWith('neg_prompt:'));
+      const hasNegativeConditioningEdge = graph.edges.some(
+        (edge) => edge.destination.field === 'negative_conditioning'
+      );
+
+      expect(hasNegativePromptNode).toBe(false);
+      expect(hasNegativeConditioningEdge).toBe(false);
+    });
+
+    it('includes negative conditioning edges in the graph when any per-step cfg exceeds 1', async () => {
+      params = {
+        ...defaultParams,
+        cfgScale: [1, 2, 1],
+      };
+
+      const { g } = await buildQwenImageGraph({
+        generationMode: 'txt2img',
+        manager: null,
+        state: {
+          system: {
+            shouldUseNSFWChecker: false,
+            shouldUseWatermarker: false,
+          },
+        } as never,
+      });
+
+      const graph = g.getGraph();
+      const nodeIds = Object.keys(graph.nodes);
+      const hasNegativePromptNode = nodeIds.some((id) => id.startsWith('neg_prompt:'));
+      const hasNegativeConditioningEdge = graph.edges.some(
+        (edge) => edge.destination.field === 'negative_conditioning'
+      );
+
+      expect(hasNegativePromptNode).toBe(true);
+      expect(hasNegativeConditioningEdge).toBe(true);
+    });
+  });
+});
+
+describe('buildQwenImageGraph', () => {
+  afterEach(() => {
+    nextId = 0;
+    params = { ...defaultParams };
+  });
+
+  it('does not include hidden Qwen reference images for generate-variant models', async () => {
+    const { g } = await buildQwenImageGraph({
+      generationMode: 'txt2img',
+      manager: null,
+      state: {
+        system: {
+          shouldUseNSFWChecker: false,
+          shouldUseWatermarker: false,
+        },
+      } as never,
+    });
+
+    const graph = g.getGraph();
+    const nodeIds = Object.keys(graph.nodes);
+    const hasReferenceCollectionNode = nodeIds.some((id) => id.startsWith('qwen_ref_img_collect:'));
+    const hasReferenceImagesEdge = graph.edges.some((edge) => edge.destination.field === 'reference_images');
+    const hasReferenceLatentsEdge = graph.edges.some((edge) => edge.destination.field === 'reference_latents');
+
+    expect(hasReferenceCollectionNode).toBe(false);
+    expect(hasReferenceImagesEdge).toBe(false);
+    expect(hasReferenceLatentsEdge).toBe(false);
+  });
+});

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

@@ -38,6 +38,19 @@ export const isQwenImageEditModel = (model: { variant?: string | null } | null):
   return 'variant' in model && model.variant === 'edit';
 };
 
+/**
+ * Determine whether classifier-free guidance (negative conditioning) should be used.
+ * CFG is only enabled when cfg_scale > 1. With cfg_scale <= 1, the negative prompt
+ * is mathematically unused and the model runs once per step instead of twice.
+ */
+export const shouldUseCfg = (cfgScale: number | number[]): boolean => {
+  if (typeof cfgScale === 'number') {
+    return cfgScale > 1;
+  }
+  // For per-step CFG arrays, enable CFG if any value exceeds 1
+  return cfgScale.some((value) => value > 1);
+};
+
 export const buildQwenImageGraph = async (arg: GraphBuilderArg): Promise<GraphBuilderReturn> => {
   const { generationMode, state, manager } = arg;
 
@@ -73,7 +86,7 @@ export const buildQwenImageGraph = async (arg: GraphBuilderArg): Promise<GraphBu
   });
 
   // Negative conditioning for CFG (only when cfg_scale > 1)
-  const useCfg = typeof cfg_scale === 'number' ? cfg_scale > 1 : true;
+  const useCfg = shouldUseCfg(cfg_scale);
   const negCond = useCfg
     ? g.addNode({
         type: 'qwen_image_text_encoder',