Nano Banana 2 503 模型过载：有界重试、暂停与出图验收

{
  "contents": [{
    "role": "user",
    "parts": [{"text": "生成一张白色背景上的蓝色陶瓷杯图片。"}]
  }],
  "generationConfig": {"responseModalities": ["TEXT", "IMAGE"]}
}

import { performance } from "node:perf_hooks";

export function retryAfterMs(value, wallNow) {
  if (!value) return 0;
  const s = value.trim();
  if (/^\d+$/.test(s)) return Number(s) * 1000;
  const date = Date.parse(s);
  return Number.isFinite(date) ? Math.max(0, date - wallNow) : 0;
}

export function imageParts(body) {
  const images = [];
  const candidates = Array.isArray(body?.candidates) ? body.candidates : [];
  for (const c of candidates) {
    const parts = Array.isArray(c?.content?.parts) ? c.content.parts : [];
    for (const p of parts) {
      if (p?.thought) continue;
      const d = p?.inlineData;
      if (typeof d?.data !== "string" || !["image/png", "image/jpeg", "image/webp"].includes(d.mimeType)) continue;
      if (!/^[A-Za-z0-9+/]+={0,2}$/.test(d.data)) continue;
      const bytes = Buffer.from(d.data, "base64");
      if (bytes.toString("base64").replace(/=+$/, "") !== d.data.replace(/=+$/, "")) continue;
      const png = bytes.subarray(0, 8).equals(Buffer.from("89504e470d0a1a0a", "hex"));
      const jpg = bytes.length > 4 && bytes[0] === 255 && bytes[1] === 216 &&
        bytes[2] === 255 && bytes.at(-2) === 255 && bytes.at(-1) === 217;
      const webp = bytes.length > 12 && bytes.toString("ascii", 0, 4) === "RIFF" &&
        bytes.toString("ascii", 8, 12) === "WEBP";
      if ((d.mimeType === "image/png" && png) || (d.mimeType === "image/jpeg" && jpg) ||
          (d.mimeType === "image/webp" && webp)) images.push({ mime: d.mimeType, bytes });
    }
  }
  return images;
}

export async function postOnce({ url, apiKey, payload, timeoutMs }) {
  const controller = new AbortController();
  const timer = setTimeout(() => controller.abort(), timeoutMs);
  try {
    const r = await fetch(url, {
      method: "POST", signal: controller.signal,
      headers: { "Content-Type": "application/json", "x-goog-api-key": apiKey },
      body: JSON.stringify(payload),
    });
    return { status: r.status, retryAfter: r.headers.get("retry-after"), text: await r.text() };
  } finally {
    clearTimeout(timer);
  }
}

export async function generateBounded({ apiKey, payload, maxAttempts = 4,
  budgetMs = 60000, perCallMs = 20000, send = postOnce,
  now = () => performance.now(), wallNow = () => Date.now(),
  sleep = ms => new Promise(resolve => setTimeout(resolve, ms)), random = Math.random }) {
  if (!Number.isInteger(maxAttempts) || maxAttempts < 1 ||
      !Number.isFinite(budgetMs) || budgetMs <= 0 || !Number.isFinite(perCallMs) || perCallMs <= 0) {
    throw new Error("invalid retry budget");
  }
  const start = now(), trace = [];
  const done = (state, extra = {}) => ({ state, elapsedMs: now() - start, trace, ...extra });
  const url = "https://generativelanguage.googleapis.com/v1/models/gemini-3.1-flash-image:generateContent";
  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
    const remaining = budgetMs - (now() - start);
    if (remaining <= 0) return done("deferred", { reason: "elapsed_budget" });
    let r;
    try {
      r = await send({ url, apiKey, payload, timeoutMs: Math.min(perCallMs, remaining) });
    } catch {
      // 请求可能已经执行：未知传输错误不自动重放 POST。
      return done("paused", { reason: "transport_result_unknown", attempt });
    }
    trace.push({ attempt, http: r.status });
    let body;
    try { body = JSON.parse(r.text); } catch { body = null; }
    if (r.status >= 200 && r.status < 300) {
      const images = imageParts(body);
      return images.length ? done("image_received", { images }) :
        done("stopped", { reason: "no_usable_image", body });
    }
    if (r.status !== 503) return done("stopped", { reason: "non_503", http: r.status, body });
    if (attempt === maxAttempts) return done("deferred", { reason: "attempt_budget", body });
    const jitter = random() * Math.min(8000, 1000 * 2 ** (attempt - 1));
    const delay = Math.max(jitter, retryAfterMs(r.retryAfter, wallNow()));
    if (delay >= budgetMs - (now() - start)) {
      return done("deferred", { reason: "retry_after_or_elapsed_budget", waitMs: delay });
    }
    await sleep(delay);
  }
}

import { readFile, writeFile } from "node:fs/promises";
import { generateBounded } from "./nano503.mjs";

export async function createOrEdit(apiKey, inputPath = null) {
  const parts = [{ text: inputPath
    ? "保留杯子形状，把杯身改成绿色。"
    : "生成一张白色背景上的蓝色陶瓷杯图片。" }];
  if (inputPath) {
    parts.push({ inlineData: {
      mimeType: "image/jpeg",
      data: (await readFile(inputPath)).toString("base64"),
    } });
  }
  const result = await generateBounded({ apiKey, payload: {
    contents: [{ role: "user", parts }],
    generationConfig: { responseModalities: ["TEXT", "IMAGE"] },
  } });
  if (result.state !== "image_received") return result;
  const ext = { "image/png": "png", "image/jpeg": "jpg", "image/webp": "webp" };
  const paths = [];
  for (const [i, image] of result.images.entries()) {
    const path = `output-${i + 1}.${ext[image.mime]}`;
    await writeFile(path, image.bytes);
    paths.push(path);
  }
  return { ...result, paths };
}