出图请求传完却不返回的兼容处理

import json
import time
import base64
import queue
import threading
import requests

MIN_BYTES = 1024          # 判定 4：比这还小不可能是一张图


def _pump(raw, q):
    """后台线程：只负责把收到的块塞进队列。"""
    try:
        for chunk in raw.stream(65536, decode_content=True):
            q.put(chunk)
        q.put(None)                       # 服务端正常收尾了
    except Exception as exc:              # 传输异常，交给主线程抛
        q.put(exc)


def _try_parse(buf):
    if len(buf) < MIN_BYTES:                    # 判定 4
        return None
    if not buf.rstrip().endswith(b"}"):         # 判定 6：极便宜的预筛
        return None
    try:
        return json.loads(buf.decode("utf-8"))  # 判定 7：最终裁决
    except ValueError:
        return None


def generate_image(url, headers, payload,
                   ttfb_timeout=180, term_grace=5, body_timeout=60):
    """非流式出图，带主动收尾。

    ttfb_timeout: 等首字节。这一段是上游在生成，慢不等于故障，要留够。
    term_grace:   数据到齐后，再等多久结束信号。等不到就主动收尾。
    body_timeout: 首字节之后，整个响应体最多再花多久。
    """
    resp = requests.post(url, headers=headers, json=payload,
                         stream=True, timeout=(10, ttfb_timeout))
    resp.raise_for_status()                     # 判定 2

    if resp.headers.get("Content-Length"):      # 判定 3
        return resp.json()                      # 长度已声明，交给库自己结束

    q = queue.Queue()
    threading.Thread(target=_pump, args=(resp.raw, q), daemon=True).start()

    buf = bytearray()
    deadline = time.monotonic() + body_timeout

    while True:
        try:
            item = q.get(timeout=term_grace)
        except queue.Empty:                     # 宽限期内没有任何新数据
            obj = _try_parse(buf)
            if obj is not None:
                resp.close()                    # 数据已到齐，主动收尾
                return obj
            if time.monotonic() > deadline:
                raise TimeoutError("响应不完整，且长时间没有新数据")
            continue                            # 还不完整，继续等

        if item is None:                        # 正常路径：服务端自己收了尾
            break
        if isinstance(item, Exception):
            raise item
        buf += item

    obj = _try_parse(buf)
    if obj is None:
        raise ValueError("响应不完整")
    return obj


def extract_image(obj):
    for cand in obj.get("candidates", []):
        for part in cand.get("content", {}).get("parts", []):
            if "inlineData" in part:
                return base64.b64decode(part["inlineData"]["data"])
    return None

const TERM_GRACE_MS = 5000;       // 数据到齐后再等多久结束信号
const TOTAL_TIMEOUT_MS = 180000;  // 总超时：必须留够上游生成的时间
const MIN_BYTES = 1024;

async function generateImage(url, headers, payload) {
  const resp = await fetch(url, {
    method: "POST",
    headers: { ...headers, "Content-Type": "application/json" },
    body: JSON.stringify(payload),
    signal: AbortSignal.timeout(TOTAL_TIMEOUT_MS),
  });
  if (!resp.ok) throw new Error(`HTTP ${resp.status}`);        // 判定 2
  if (resp.headers.get("content-length")) return resp.json();  // 判定 3

  const reader = resp.body.getReader();
  const chunks = [];
  let total = 0;

  while (true) {
    // 用 Promise.race 给「等下一块数据」加一个宽限期上限
    const next = reader.read();
    const timer = new Promise((r) => setTimeout(() => r("GRACE"), TERM_GRACE_MS));
    const winner = await Promise.race([next, timer]);

    if (winner === "GRACE") {
      const parsed = tryParse(chunks, total);
      if (parsed) {                 // 数据已完整，是服务端没收尾
        reader.cancel().catch(() => {});
        return parsed;
      }
      continue;                     // 数据还不完整，继续等
    }

    const { done, value } = winner;
    if (done) break;                // 正常路径：服务端收了尾
    chunks.push(value);
    total += value.length;
  }

  const parsed = tryParse(chunks, total);
  if (!parsed) throw new Error("响应不完整");
  return parsed;
}

function tryParse(chunks, total) {
  if (total < MIN_BYTES) return null;                 // 判定 4
  const buf = new Uint8Array(total);
  let off = 0;
  for (const c of chunks) { buf.set(c, off); off += c.length; }
  const text = new TextDecoder().decode(buf).trimEnd();
  if (!text.endsWith("}")) return null;               // 判定 6
  try { return JSON.parse(text); } catch { return null; }   // 判定 7
}