gemini-3.1-flash-image-preview ignores imageConfig.imageSize — always returns 1K

[didistudy]

Environment details

• SDK: @google/genai v1.45.0 and v1.48.0 (tested both, same behavior)
• Endpoint: Vertex AI (vertexai: true, API version v1beta1)
• Location: global
• Platform: Node.js 20, Cloud Run (europe-west1)

Summary

gemini-3.1-flash-image-preview silently ignores the imageConfig.imageSize parameter in generateContent requests. The model always produces ~1K resolution output (928x1152) regardless of whether imageSize is set to "2K" or "4K".

The same code path works correctly with gemini-3-pro-image-preview, which respects imageSize and produces 4K output as expected.

Steps to reproduce

import { GoogleGenAI } from '@google/genai';

const client = new GoogleGenAI({ vertexai: true, project: 'my-project', location: 'global' });

const result = await client.models.generateContent({
  model: 'gemini-3.1-flash-image-preview',
  config: {
    responseModalities: ['TEXT', 'IMAGE'],
    imageConfig: {
      imageSize: '2K',   // Also tried '4K' — same result
    },
    temperature: 0.4,
  },
  contents: [
    {
      role: 'user',
      parts: [
        { text: 'A product photo of a dress on a model' },
        { inlineData: { data: '<base64_image>', mimeType: 'image/png' } },
      ],
    },
  ],
});

// Result: image is always ~1K (928x1152), never 2K or 4K

Expected behavior

Output image should match the requested imageSize:

• "2K" → largest dimension ~2048px
• "4K" → largest dimension ~4096px

Per Google's documentation: "Gemini 3 image models generate 1K images by default but can also output 2K, 4K, and 512 (0.5K) images."

The model page also lists "New support for 0.5K, 2K and 4K" as a feature.

Actual behavior

Output is always ~1K (928x1152) regardless of imageSize value. No error is returned — the parameter is silently ignored.

Comparison with gemini-3-pro-image-preview

Using the exact same code with model: 'gemini-3-pro-image-preview' produces correct 4K output. This confirms:

• The SDK correctly serializes imageConfig.imageSize into the request
• The Vertex AI endpoint accepts the parameter
• The issue is specific to gemini-3.1-flash-image-preview

Verification

We inspected the SDK source and confirmed that imageConfigToVertex in @google/genai correctly maps imageSize to generationConfig.imageConfig.imageSize in the Vertex AI REST request body. The transformation function is identical between SDK v1.45.0 and v1.48.0 — this is not an SDK serialization issue.

Impact

Users requesting 2K or 4K resolution receive 1K output without any error indication.

[didistudy]

Additional context: A similar report was posted today on the Google AI Developers Forum — another user experiencing the same issue with Nano Banana 2 (gemini-3.1-flash-image-preview) unable to generate higher resolution images:

https://discuss.ai.google.dev/t/google-ai-studios-api-keys-nano-banana-2-cannot-generate-4k-quality-images-only-512k-2k-quality/137597

This suggests the issue affects both the Vertex AI and Gemini API endpoints.

[Varun-S10]

Hi @didistudy, Thank you for raising this issue and for providing the code. We have tried to reproduce the problem, but it appears to be working as expected on our end. The system is correctly returning images based on the specified resolution. We tested this using both Vertex AI and the Gemini API. I have attached the working code for your reference. Let me know if this works for you.

import { GoogleGenAI } from '@google/genai';
import * as fs from 'node:fs';
import 'dotenv/config';

const client = new GoogleGenAI({ });

  const inputImagePath = 'image.png'; 
  let base64Image = '';
  
  try {
    const imageBuffer = fs.readFileSync(inputImagePath);
    base64Image = imageBuffer.toString('base64');
  } catch (error) {
    console.error(`Error: Could not read input image at ${inputImagePath}. Please make sure the file exists.`);
  }

const result = await client.models.generateContent({
  model: 'gemini-3.1-flash-image-preview',
  config: {
    responseModalities: ['TEXT', 'IMAGE'],
    imageConfig: {
      imageSize: '2K',   // Also tried '4K'
    },
    temperature: 0.4,
  },
  contents: [
    {
      role: 'user',
      parts: [
       { text: 'Da Vinci style anatomical sketch of a dissected Monarch butterfly. Detailed drawings of the head, wings, and legs on textured parchment with notes in English.' },
        { inlineData: { data: base64Image, mimeType: 'image/png' } },
      ],
    },
  ],
});

const parts = result.candidates[0].content.parts;
  console.log("===============parts===================================");
  console.log(parts);
  let imageCount = 1;

  for (const part of parts) {
    if (part.text) {
      console.log("\nText Output:");
      console.log(part.text);
    } else if (part.inlineData) {
      const imageData = part.inlineData.data;
      const buffer = Buffer.from(imageData, 'base64');
      const outputFilename = `output_${imageCount}_2K.png`;
      
      fs.writeFileSync(outputFilename, buffer);
      console.log(`\nSuccess! Image saved as ${outputFilename}`);
      imageCount++;
    }
  }

[didistudy]

Hi @Varun-S10, thank you for looking into this and sharing the reference code!

We investigated further and found that the discrepancy comes down to Vertex AI vs Gemini API. Your reference code uses new GoogleGenAI({}) (Gemini API with API key), while we use Vertex AI (vertexai: true, location: 'global').

We ran a controlled test — same image, same model, same SDK (v1.48.0), same imageSize: '2K', same inlineData input — only varying the endpoint:

Endpoint	Output dimensions	Max dimension
Gemini API (API key)	1536×2730	2730px (2K+) ✅
Vertex AI (location: 'global')	768×1365	1365px (~1K) ❌

The Gemini API correctly respects imageSize, but the Vertex AI global endpoint silently ignores it for gemini-3.1-flash-image-preview. This is why you couldn't reproduce the issue — the Gemini API path works fine.

For reference, gemini-3-pro-image-preview respects imageSize correctly on the same project via Vertex AI global — the issue appears specific to the flash model on the Vertex AI side. Could you also confirm there are no project-level restrictions that might cap output resolution for specific models on Vertex AI?

Thanks again for your help!

[Varun-S10]

Hi @didistudy, We also tried to reproduce the issue using Vertex AI, but it is working correctly on our end. I have attached the code we used for testing. Could you please run this code and let me know if it works for you, or if you are still facing the issue?

import { GoogleGenAI } from '@google/genai';
import * as fs from 'node:fs';
import 'dotenv/config';

const client = new GoogleGenAI({ 
  vertexai: true,
    project: process.env.GOOGLE_CLOUD_PROJECT,
    location: process.env.GOOGLE_CLOUD_LOCATION , });

  const inputImagePath = 'image.png'; 
  let base64Image = '';
  
  try {
    const imageBuffer = fs.readFileSync(inputImagePath);
    base64Image = imageBuffer.toString('base64');
  } catch (error) {
    console.error(`Error: Could not read input image at ${inputImagePath}. Please make sure the file exists.`);
  }

const result = await client.models.generateContent({
  model: 'gemini-3.1-flash-image-preview',
  config: {
    responseModalities: ['TEXT', 'IMAGE'],
    imageConfig: {
      imageSize: '2K',   // Also tried '4K'
    },
    temperature: 0.4,
  },
  contents: [
    {
      role: 'user',
      parts: [
       { text: 'Da Vinci style anatomical sketch of a dissected Monarch butterfly. Detailed drawings of the head, wings, and legs on textured parchment with notes in English.' },
        { inlineData: { data: base64Image, mimeType: 'image/png' } },
      ],
    },
  ],
});

const parts = result.candidates[0].content.parts;
  console.log("===============parts===================================");
  console.log(parts);
  let imageCount = 1;

  for (const part of parts) {
    if (part.text) {
      console.log("\nText Output:");
      console.log(part.text);
    } else if (part.inlineData) {
      const imageData = part.inlineData.data;
      const buffer = Buffer.from(imageData, 'base64');
      const outputFilename = `vertex_output_${imageCount}_2K.png`;
      
      fs.writeFileSync(outputFilename, buffer);
      console.log(`\nSuccess! Image saved as ${outputFilename}`);
      imageCount++;
    }
  }

[JamesDerrickHH]

I am seeing the same behaviour as the person who raised the issue
Also using vertex and global
And only getting 1024x1024 image with model: "gemini-3.1-flash-image-preview", imageSize: "2K" and aspectRatio: "1:1"
I get a 2048x2048 image when using gemini-3-pro-image-preview

[BizerNotNull]

I’ve encountered the same phenomenon, but it’s intermittent. The issue is that out of two 2K images, the first one always ends up being 1K, but the second one is right 2K. I tried to change the location , that's not useful.

[Varun-S10]

Hi @JamesDerrickHH, @BizerNotNull, We have tried reproducing this issue multiple times on our end, but everything seems to be working as expected. To help us investigate further, could you please share the exact google-genai version you are using, along with a minimal reproducible code?

[BizerNotNull]

@Varun-S10 Based on my testing, it appears to be an issue with the Vertex gemini-3.1-flash-image-preview model itself. I can reproduce the exact same result using the REST API, so it doesn't seem to be related to the SDK.

For a minimal reproducible example, you can try this:

curl -X POST \
    -H "Authorization: Bearer xxx" \
    -H "Content-Type: application/json; charset=utf-8" \
    -d '{
        "contents": [{
            "role": "user",
            "parts": [{"text": "Impressionist painting"}]
        }],
        "generationConfig": {
            "aspectRatio": "16:9",
            "imageSize": "2K"
        }
    }' \
    "https://aiplatform.googleapis.com/v1/projects/xxx/locations/global/publishers/google/models/gemini-3.1-flash-image-preview:generateContent"

If it ultimately turns out that this is unrelated to the SDK, I apologize for bothering you.

[JamesDerrickHH]

I'm running mine from within an azure function app, using the @google/genai v1.47

export async function generate(request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
    context.log(`Http function processed request for url "${request.url}"`);

    const projectId = 'projectId';
    const location = 'global'

    const authOptions = {
        credentials: {
            client_email: process.env["GOOGLE_CLOUD_KEY_CLIENT_EMAIL"],
            private_key: process.env["GOOGLE_CLOUD_KEY_PRIVATE_KEY"]?.replace(/\\n/g, '\n')
        }
    }

    const ai = new GoogleGenAI({
        vertexai: true,
        project: projectId,
        location: location,
        googleAuthOptions: authOptions
    })

    try {

        const _request = await request.json();
        const model = _request['model'] || 'gemini-2.5-flash-image'
        const prompt = _request['prompt'];
        const aspectRatio = _request['aspect_ratio'] || "1:1";
        const imageSize = _request['image_size'] || "1K";
        const grounding = _request['grounding'] || [];
        context.log("Using model:", model);
        context.log("Received prompt:", prompt);
        context.log("Aspect Ratio:", aspectRatio);
        context.log("Image Size:", imageSize);
        context.log("Grounding Tools:", grounding);

        if(!prompt) {
            throw new Error("Prompt is required in the request body.");
        }

        const groundingTools = grounding.map((g: string) => { return {[g]:{}} })

        const result = await ai.models.generateContent({
            model: model,
            contents: prompt,
            config: {
                imageConfig: {
                    aspectRatio,
                    imageSize,
                    personGeneration: 'ALLOW_ALL'
                },
                tools: groundingTools
            }
        });
        context.log(result.candidates[0])
        const contentParts = result.candidates[0].content.parts
        const data = contentParts.find(part => part.inlineData)

        return { body: JSON.stringify({ output: data.inlineData.data }) };

    } catch (error) {
        context.error("Failed to generate content:", error);
        if(error instanceof ApiError) {
            const parsedError = JSON.parse(error.message);
            return { status: error.status || 500, body: JSON.stringify(parsedError) };
        }
        return { status: 500, body: JSON.stringify({ error: error?.message || error }) };
    }
};

Called with a payload that looks like this...

{
    "model": "gemini-3.1-flash-image-preview",
    "prompt": "Private residential landscape with entertaining terrace, swimming pool area, outdoor kitchen, fire pit seating, privacy screening, seasonal garden beds, water feature, lighting design, sustainable plant selection, irrigation zones, lawn alternatives, tree specimens, property boundary treatment, maintenance considerations",
    "aspect_ratio": "1:1",
    "image_size": "2K"
}

[JamesDerrickHH]

Early days but I think including responseModalities: ['IMAGE'] fixes it for me

[jackshi0912]

+1 seems like a backend issue. Same problem in golang genai api.