> ## Documentation Index
> Fetch the complete documentation index at: https://docs.mixroute.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Gemini 原生（图像，流式）

> Gemini 原生图像生成模型，streamGenerateContent 流式文生图与图生图

## 简介

`streamGenerateContent` 是 Gemini 原生 `generateContent` 的流式版本。Nano Banana 对应 Google Gemini 原生图像生成能力，包括 Nano Banana（`gemini-2.5-flash-image`）、Nano Banana 2（`gemini-3.1-flash-image`、`gemini-3.1-flash-image-preview`）与 Nano Banana Pro（`gemini-3-pro-image`）。调用 MixRoute 原生流式接口时，使用端点 `POST /v1/models/<model>:streamGenerateContent?alt=sse`，并传入符合 Gemini 原生结构的 JSON Payload，支持文生图、图生图及多图融合等能力。

流式接口返回 Server-Sent Events（SSE），客户端应逐行读取 `data:` 事件内容，而不是把整个响应体当作单个 JSON 对象解析。

完整参数与多模型说明请参见 [图片生成](/cn/api-reference/endpoint/image-generation)。

## 认证

Bearer Token，如 `Bearer sk-xxxxxxxxxx`

## 支持的模型

| 模型 ID                            | 说明                                         |
| -------------------------------- | ------------------------------------------ |
| `gemini-2.5-flash-image`         | Nano Banana，高性价比文生图/图生图，输出为固定 1024px 级尺寸   |
| `gemini-3.1-flash-image`         | Nano Banana 2，卓越画质与速度平衡，支持 1K、2K、4K 输出     |
| `gemini-3.1-flash-image-preview` | Nano Banana 2 预览版，支持图像生成测试                 |
| `gemini-3-pro-image`             | Nano Banana Pro，更高画质与极强细节控制，支持 1K、2K、4K 输出 |

## 基础示例

<Tabs>
  <Tab title="文生图">
    ```bash theme={null}
    curl -X POST "https://api.mixroute.ai/v1/models/gemini-3.1-flash-image:streamGenerateContent?alt=sse" \
      -H "Authorization: Bearer sk-xxxxxxxxxx" \
      -H "Content-Type: application/json" \
      --no-buffer \
      -d '{
        "contents": [
          {
            "role": "user",
            "parts": [
              {
                "text": "一只可爱的橙色小猫坐在花园里，阳光明媚，高质量摄影"
              }
            ]
          }
        ],
        "generationConfig": {
          "responseModalities": [
            "TEXT",
            "IMAGE"
          ],
          "imageConfig": {
            "aspectRatio": "16:9",
            "imageSize": "2K"
          }
        }
      }'
    ```
  </Tab>

  <Tab title="图生图">
    ```bash theme={null}
    curl -X POST "https://api.mixroute.ai/v1/models/gemini-3.1-flash-image:streamGenerateContent?alt=sse" \
      -H "Authorization: Bearer sk-xxxxxxxxxx" \
      -H "Content-Type: application/json" \
      --no-buffer \
      -d '{
        "contents": [
          {
            "role": "user",
            "parts": [
              {
                "text": "根据这张图生成一张俯瞰广州塔的图片"
              },
              {
                "inlineData": {
                  "mimeType": "image/png",
                  "data": "iVBORw0KGgoAAA..."
                }
              }
            ]
          }
        ],
        "generationConfig": {
          "responseModalities": [
            "TEXT",
            "IMAGE"
          ],
          "imageConfig": {
            "aspectRatio": "16:9",
            "imageSize": "2K"
          }
        }
      }'
    ```
  </Tab>
</Tabs>

## 请求参数

<ParamField path="model" type="string" required>
  Gemini 原生（图像）模型标识，位于 URL 路径中，如 `gemini-3.1-flash-image` 或 `gemini-3-pro-image`。
</ParamField>

<ParamField query="alt" type="string">
  流式响应格式。传入 `sse` 时，接口以 Server-Sent Events 返回流式 `GenerateContentResponse` 数据。
</ParamField>

<ParamField body="contents" type="array" required>
  原生对话或图像内容列表。

  <Expandable title="contents 子字段">
    <ParamField body="contents[].role" type="string">
      角色标识，通常为 `"user"`。
    </ParamField>

    <ParamField body="contents[].parts" type="array" required>
      内容块列表。每个元素可以是文本提示词（`{"text": "..."}`）或内联媒体数据（`{"inlineData": {"mimeType": "...", "data": "<BASE64>"}}`）。

      <Expandable title="parts 子字段">
        <ParamField body="contents[].parts[].inlineData" type="object">
          内联媒体数据对象。

          <Expandable title="inlineData 子字段">
            <ParamField body="contents[].parts[].inlineData.mimeType" type="string">
              媒体类型的 MIME 格式，如 `"image/png"`、`"image/jpeg"`、`"image/webp"` 等。
            </ParamField>

            <ParamField body="contents[].parts[].inlineData.data" type="string">
              图像数据的 Base64 编码字符串（不含前缀）。
            </ParamField>
          </Expandable>
        </ParamField>
      </Expandable>
    </ParamField>
  </Expandable>
</ParamField>

<ParamField body="generationConfig" type="object">
  生成配置参数。

  <Expandable title="generationConfig 子字段">
    <ParamField body="generationConfig.responseModalities" type="array">
      响应模态。如传入该字段，需包含 `"IMAGE"`；常用写法为 `["TEXT", "IMAGE"]`。
    </ParamField>

    <ParamField body="generationConfig.imageConfig" type="object">
      图像生成配置。

      <Expandable title="imageConfig 子字段">
        <ParamField body="generationConfig.imageConfig.aspectRatio" type="string">
          输出图像的宽高比。`gemini-2.5-flash-image` 与 `gemini-3-pro-image` 支持 `"1:1"`、`"2:3"`、`"3:2"`、`"3:4"`、`"4:3"`、`"4:5"`、`"5:4"`、`"9:16"`、`"16:9"`、`"21:9"`；`gemini-3.1-flash-image` 系列另外支持 `"1:4"`、`"4:1"`、`"1:8"`、`"8:1"`。
        </ParamField>

        <ParamField body="generationConfig.imageConfig.imageSize" type="string">
          输出分辨率或尺寸档位。`gemini-2.5-flash-image` 不使用该字段，按宽高比返回固定 1024px 级尺寸；`gemini-3.1-flash-image` 系列与 `gemini-3-pro-image` 支持 `"1K"`、`"2K"`、`"4K"`。
        </ParamField>
      </Expandable>
    </ParamField>
  </Expandable>
</ParamField>

更多参数与各模型差异请参见 [图片生成](/cn/api-reference/endpoint/image-generation)。

## 响应格式

接口返回 SSE 流。每个 `data:` 事件的内容是一个 JSON 格式的 `GenerateContentResponse` 实例；图像可能以一个或多个 Base64 编码的 `inlineData` 形式出现在某个或多个 chunk 的 `candidates` 中。客户端应逐行读取 SSE，并分别解析每个 `data:` 后的 JSON。

| 字段                                                 | 类型      | 说明                                             |
| -------------------------------------------------- | ------- | ---------------------------------------------- |
| `data`                                             | string  | SSE 事件数据行，内容为一个 JSON `GenerateContentResponse` |
| `candidates[].content.parts[].text`                | string  | 模型返回的文本片段                                      |
| `candidates[].content.parts[].inlineData.mimeType` | string  | 图像 MIME 类型（如 `image/png`）                      |
| `candidates[].content.parts[].inlineData.data`     | string  | 图像的 Base64 编码数据                                |
| `candidates[].finishReason`                        | string  | 生成结束原因，如 `"STOP"`                              |
| `usageMetadata.promptTokenCount`                   | integer | 输入 token 数                                     |
| `usageMetadata.candidatesTokenCount`               | integer | 输出 token 数（图像 token）                           |
| `modelVersion`                                     | string  | 实际使用的模型版本                                      |
| `responseId`                                       | string  | 响应唯一标识                                         |

<RequestExample>
  ```bash cURL theme={null}
  curl --request POST \
    --url 'https://api.mixroute.ai/v1/models/gemini-3.1-flash-image:streamGenerateContent?alt=sse' \
    --header 'Authorization: Bearer sk-xxxxxxxxxx' \
    --header 'Content-Type: application/json' \
    --no-buffer \
    --data '{
      "contents": [
        {
          "role": "user",
          "parts": [
            {
              "text": "一只可爱的橙色小猫坐在花园里"
            }
          ]
        }
      ],
      "generationConfig": {
        "responseModalities": [
          "TEXT",
          "IMAGE"
        ],
        "imageConfig": {
          "aspectRatio": "16:9",
          "imageSize": "2K"
        }
      }
    }'
  ```

  ```python Python theme={null}
  import json
  import requests

  url = "https://api.mixroute.ai/v1/models/gemini-3.1-flash-image:streamGenerateContent?alt=sse"
  headers = {
      "Authorization": "Bearer sk-xxxxxxxxxx",
      "Content-Type": "application/json"
  }
  payload = {
      "contents": [
          {
              "role": "user",
              "parts": [
                  {
                      "text": "一只可爱的橙色小猫坐在花园里"
                  }
              ]
          }
      ],
      "generationConfig": {
          "responseModalities": [
              "TEXT",
              "IMAGE"
          ],
          "imageConfig": {
              "aspectRatio": "16:9",
              "imageSize": "2K"
          }
      }
  }

  with requests.post(url, json=payload, headers=headers, stream=True) as response:
      response.raise_for_status()
      for line in response.iter_lines(decode_unicode=True):
          if not line or not line.startswith("data: "):
              continue
          chunk = json.loads(line.removeprefix("data: "))
          print(chunk)
  ```

  ```javascript JavaScript theme={null}
  const response = await fetch('https://api.mixroute.ai/v1/models/gemini-3.1-flash-image:streamGenerateContent?alt=sse', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer sk-xxxxxxxxxx',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      contents: [
        {
          role: "user",
          parts: [
            {
              text: "一只可爱的橙色小猫坐在花园里"
            }
          ]
        }
      ],
      generationConfig: {
        responseModalities: [
          "TEXT",
          "IMAGE"
        ],
        imageConfig: {
          aspectRatio: "16:9",
          imageSize: "2K"
        }
      }
    })
  });

  const reader = response.body.getReader();
  const decoder = new TextDecoder();
  let buffer = "";

  while (true) {
    const { value, done } = await reader.read();
    if (done) break;
    buffer += decoder.decode(value, { stream: true });
    const lines = buffer.split("\n");
    buffer = lines.pop() ?? "";

    for (const line of lines) {
      if (!line.startsWith("data: ")) continue;
      const chunk = JSON.parse(line.slice("data: ".length));
      console.log(chunk);
    }
  }

  if (buffer.startsWith("data: ")) {
    const chunk = JSON.parse(buffer.slice("data: ".length));
    console.log(chunk);
  }
  ```

  ```php PHP theme={null}
  <?php
  $client = new GuzzleHttp\Client();
  $response = $client->post('https://api.mixroute.ai/v1/models/gemini-3.1-flash-image:streamGenerateContent?alt=sse', [
      'headers' => [
          'Authorization' => 'Bearer sk-xxxxxxxxxx',
          'Content-Type' => 'application/json',
      ],
      'stream' => true,
      'json' => [
          'contents' => [
              [
                  'role' => 'user',
                  'parts' => [
                      [
                          'text' => '一只可爱的橙色小猫坐在花园里'
                      ]
                  ]
              ]
          ],
          'generationConfig' => [
              'responseModalities' => [
                  'TEXT',
                  'IMAGE'
              ],
              'imageConfig' => [
                  'aspectRatio' => '16:9',
                  'imageSize' => '2K'
              ]
          ]
      ]
  ]);

  $body = $response->getBody();
  $buffer = '';
  while (!$body->eof()) {
      $buffer .= $body->read(8192);
      $lines = explode("\n", $buffer);
      $buffer = array_pop($lines);
      foreach ($lines as $line) {
          if (str_starts_with($line, 'data: ')) {
              print_r(json_decode(substr($line, 6), true));
          }
      }
  }

  if (str_starts_with($buffer, 'data: ')) {
      print_r(json_decode(substr($buffer, 6), true));
  }
  ```

  ```go Go theme={null}
  package main

  import (
      "bufio"
      "bytes"
      "encoding/json"
      "fmt"
      "net/http"
      "strings"
  )

  func main() {
      payload := map[string]interface{}{
          "contents": []interface{}{
              map[string]interface{}{
                  "role": "user",
                  "parts": []interface{}{
                      map[string]interface{}{
                          "text": "一只可爱的橙色小猫坐在花园里",
                      },
                  },
              },
          },
          "generationConfig": map[string]interface{}{
              "responseModalities": []string{
                  "TEXT",
                  "IMAGE",
              },
              "imageConfig": map[string]interface{}{
                  "aspectRatio": "16:9",
                  "imageSize":   "2K",
              },
          },
      }
      body, _ := json.Marshal(payload)
      req, _ := http.NewRequest("POST", "https://api.mixroute.ai/v1/models/gemini-3.1-flash-image:streamGenerateContent?alt=sse", bytes.NewBuffer(body))
      req.Header.Set("Authorization", "Bearer sk-xxxxxxxxxx")
      req.Header.Set("Content-Type", "application/json")

      resp, _ := http.DefaultClient.Do(req)
      defer resp.Body.Close()

      reader := bufio.NewReader(resp.Body)
      for {
          line, err := reader.ReadString('\n')
          if len(line) > 0 {
              line = strings.TrimSuffix(line, "\n")
              line = strings.TrimSuffix(line, "\r")
          }
          if strings.HasPrefix(line, "data: ") {
              fmt.Println(strings.TrimPrefix(line, "data: "))
          }
          if err != nil {
              break
          }
      }
  }
  ```

  ```java Java theme={null}
  import java.net.http.*;
  import java.net.URI;

  HttpClient client = HttpClient.newHttpClient();
  String json = """
      {
          "contents": [
              {
                  "role": "user",
                  "parts": [
                      {
                          "text": "一只可爱的橙色小猫坐在花园里"
                      }
                  ]
              }
          ],
          "generationConfig": {
              "responseModalities": [
                  "TEXT",
                  "IMAGE"
              ],
              "imageConfig": {
                  "aspectRatio": "16:9",
                  "imageSize": "2K"
              }
          }
      }
      """;
  HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://api.mixroute.ai/v1/models/gemini-3.1-flash-image:streamGenerateContent?alt=sse"))
      .header("Authorization", "Bearer sk-xxxxxxxxxx")
      .header("Content-Type", "application/json")
      .POST(HttpRequest.BodyPublishers.ofString(json))
      .build();

  HttpResponse<java.util.stream.Stream<String>> response = client.send(
      request,
      HttpResponse.BodyHandlers.ofLines()
  );

  response.body()
      .filter(line -> line.startsWith("data: "))
      .forEach(line -> System.out.println(line.substring("data: ".length())));
  ```

  ```ruby Ruby theme={null}
  require 'net/http'
  require 'json'

  uri = URI('https://api.mixroute.ai/v1/models/gemini-3.1-flash-image:streamGenerateContent?alt=sse')
  http = Net::HTTP.new(uri.host, uri.port)
  http.use_ssl = true

  request = Net::HTTP::Post.new(uri)
  request['Authorization'] = 'Bearer sk-xxxxxxxxxx'
  request['Content-Type'] = 'application/json'
  request.body = {
    contents: [
      {
        role: 'user',
        parts: [
          {
            text: '一只可爱的橙色小猫坐在花园里'
          }
        ]
      }
    ],
    generationConfig: {
      responseModalities: [
        'TEXT',
        'IMAGE'
      ],
      imageConfig: {
        aspectRatio: '16:9',
        imageSize: '2K'
      }
    }
  }.to_json

  http.request(request) do |response|
    buffer = ''
    response.read_body do |chunk|
      buffer << chunk
      lines = buffer.split("\n")
      buffer = lines.pop || ''

      lines.each do |line|
        line = line.delete_suffix("\r")
        next unless line.start_with?('data: ')

        puts JSON.parse(line.delete_prefix('data: '))
      end
    end

    if buffer.start_with?('data: ')
      puts JSON.parse(buffer.delete_prefix('data: '))
    end
  end
  ```
</RequestExample>

<ResponseExample>
  ```text Response theme={null}
  data: {"candidates":[{"content":{"role":"model","parts":[{"text":"正在生成图像。"}]}}],"modelVersion":"gemini-3.1-flash-image","responseId":"stream-response-id"}

  data: {"candidates":[{"content":{"role":"model","parts":[{"inlineData":{"mimeType":"image/png","data":"iVBORw0KGgoAAAANSUhEUgAAAAQAAAAECAIA..."}}]},"finishReason":"STOP"}],"usageMetadata":{"promptTokenCount":13,"candidatesTokenCount":1680,"totalTokenCount":1693,"promptTokensDetails":[{"modality":"TEXT","tokenCount":13}],"candidatesTokensDetails":[{"modality":"IMAGE","tokenCount":1680}]},"modelVersion":"gemini-3.1-flash-image","responseId":"stream-response-id"}
  ```
</ResponseExample>