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"
      }
    }
  }'

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)

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
$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));
}

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
        }
    }
}

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())));

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

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"}