Nano Banana Pro: ошибка RESOURCE_EXHAUSTED и восстановление генерации

{
  "error": {
    "code": 429,
    "status": "RESOURCE_EXHAUSTED",
    "message": "Resource has been exhausted (e.g. check quota)."
  }
}

[
  {"id": "hero", "prompt": "Создай студийное изображение красного чайника на белом фоне"},
  {"id": "detail", "prompt": "Создай крупный план ручки красного чайника на белом фоне"}
]

python -m pip install httpx Pillow

python recover.py jobs.json out-python

import asyncio, base64, hashlib, io, json, os, random, re, sys, time
from email.utils import parsedate_to_datetime
from pathlib import Path
import httpx
from PIL import Image

MODEL = "gemini-3-pro-image"
URL = f"https://generativelanguage.googleapis.com/v1beta/models/{MODEL}:generateContent"
CONFIG = {"responseModalities": ["TEXT", "IMAGE"],
          "imageConfig": {"aspectRatio": "16:9", "imageSize": "1K"}}

def save_json(path, data):
    temp = path.with_suffix(".tmp")
    temp.write_text(json.dumps(data, ensure_ascii=False, indent=2))
    temp.replace(path)

def decision(status, body, headers, wall):
    err = body.get("error", {})
    details = err.get("details", [])
    violations = [v for d in details
                  if d.get("@type", "").endswith("QuotaFailure")
                  for v in d.get("violations", [])]
    zero = any("quotaValue" in v and str(v["quotaValue"]) == "0"
               for v in violations)
    text = " ".join([str(err.get("message", ""))] +
                    [json.dumps(v) for v in violations]).lower()
    daily = bool(re.search(r"per.?day|daily|requestsperday|суточ", text))
    zero = zero or bool(re.search(r"\blimit\s*[:=]\s*0\b", text))
    if status == 429 and (zero or daily):
        return "stop", 0
    if status not in (429, 503):
        return "stop", 0
    floors = [0.0]
    value = headers.get("retry-after", "").strip()
    if re.fullmatch(r"\d+", value):
        floors.append(float(value))
    elif value:
        try:
            floors.append(max(0, parsedate_to_datetime(value).timestamp() - wall))
        except (ValueError, TypeError, OverflowError):
            pass
    for d in details:
        if d.get("@type", "").endswith("RetryInfo"):
            m = re.fullmatch(r"(\d+(?:\.\d+)?)s", d.get("retryDelay", ""))
            if m:
                floors.append(float(m[1]))
    return "retry", max(floors)

def images(body):
    found = []
    for c in body.get("candidates", []):
        for p in c.get("content", {}).get("parts", []):
            b = p.get("inlineData", {})
            mime = b.get("mimeType")
            if mime not in ("image/png", "image/jpeg", "image/webp"):
                continue
            raw = base64.b64decode(b.get("data", ""), validate=True)
            with Image.open(io.BytesIO(raw)) as image:
                image.verify()
                kind = image.format
            expected = {"image/png": "PNG", "image/jpeg": "JPEG", "image/webp": "WEBP"}
            if kind != expected[mime]:
                raise ValueError("MIME не совпадает с файлом")
            found.append((mime.split("/")[1], raw))
    if not found:
        raise ValueError("Нет подтверждённого изображения; проверьте promptFeedback/finishReason")
    return found

async def post(prompt, timeout):
    key = os.environ["GEMINI_API_KEY"]
    async with httpx.AsyncClient(timeout=timeout, follow_redirects=False) as client:
        response = await asyncio.wait_for(client.post(
            URL, headers={"x-goog-api-key": key},
            json={"contents": [{"parts": [{"text": prompt}]}],
                  "generationConfig": CONFIG}), timeout)
        return response.status_code, dict(response.headers), response.json()

async def run(jobs, directory, send=post, clock=time.monotonic,
              wall=time.time, sleep=asyncio.sleep, rand=random.random, budget=120):
    directory = Path(directory)
    directory.mkdir(parents=True, exist_ok=True)
    path = directory / "state.json"
    state = json.loads(path.read_text()) if path.exists() else {}
    deadline = clock() + budget
    ids = [j["id"] for j in jobs]
    if len(ids) != len(set(ids)) or any(not re.fullmatch(r"[A-Za-z0-9_-]+", x) for x in ids):
        raise ValueError("Нужны уникальные безопасные id")
    for job in jobs:
        fingerprint = hashlib.sha256(json.dumps(
            [MODEL, CONFIG, job["prompt"]], sort_keys=True).encode()).hexdigest()
        record = state.setdefault(job["id"], {"fingerprint": fingerprint, "attempts": 0})
        if record["fingerprint"] != fingerprint:
            raise ValueError("Изменённое задание требует нового id")
        if record.get("status") == "done":
            for f in record["files"]:
                raw = (directory / f["name"]).read_bytes()
                if hashlib.sha256(raw).hexdigest() != f["sha256"]:
                    raise ValueError("Подтверждённый файл изменён")
            continue
        if record.get("status") in ("inflight", "unknown", "stop", "review"):
            continue
        while record["attempts"] < 4:
            remaining = deadline - clock()
            wait = max(0, record.get("notBefore", 0) - wall())
            if wait + 1 >= remaining:
                record["status"] = "deferred"
                save_json(path, state)
                return state
            if wait:
                await sleep(wait)
            timeout = min(30, deadline - clock())
            if timeout < 1:
                return state
            record.update(status="inflight", attempts=record["attempts"] + 1)
            save_json(path, state)  # Запись ДО отправки
            try:
                status, headers, body = await send(job["prompt"], timeout)
            except Exception:
                record["status"] = "unknown"
                save_json(path, state)
                return state  # Исход POST неизвестен
            if status == 200:
                try:
                    output = images(body)
                    files = []
                    for i, (ext, raw) in enumerate(output):
                        name = f"{job['id']}-{i}.{ext}"
                        target = directory / name
                        temp = target.with_suffix(".tmp")
                        temp.write_bytes(raw)
                        temp.replace(target)
                        files.append({"name": name, "sha256": hashlib.sha256(raw).hexdigest()})
                    record.update(status="done", files=files)
                except Exception:
                    record["status"] = "review"
                save_json(path, state)
                if record["status"] != "done":
                    return state
                break
            action, floor = decision(status, body, headers, wall())
            record.update(status="stop" if action == "stop" else "deferred", http=status)
            if action == "retry":
                delay = max(floor, min(16, 2 ** record["attempts"]) + rand())
                record["notBefore"] = wall() + delay
            save_json(path, state)
            if action == "stop" or record["attempts"] == 4:
                return state
    return state

if __name__ == "__main__":
    jobs = json.loads(Path(sys.argv[1]).read_text())
    result = asyncio.run(run(jobs, sys.argv[2]))
    print(json.dumps(result, ensure_ascii=False, indent=2))

npm install sharp

node recover.mjs jobs.json out-node

import fs from 'node:fs/promises';
import path from 'node:path';
import { createHash } from 'node:crypto';
import { pathToFileURL } from 'node:url';
import sharp from 'sharp';

const model = 'gemini-3-pro-image';
const url = `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent`;
const config = { responseModalities: ['TEXT', 'IMAGE'],
  imageConfig: { aspectRatio: '16:9', imageSize: '1K' } };
const hash = data => createHash('sha256').update(data).digest('hex');
const pause = seconds => new Promise(resolve => setTimeout(resolve, seconds * 1000));
async function save(file, state) {
  await fs.writeFile(file + '.tmp', JSON.stringify(state, null, 2));
  await fs.rename(file + '.tmp', file);
}
export function decision(status, body, headers, now) {
  const error = body.error ?? {}, details = error.details ?? [];
  const violations = details.filter(d => d['@type']?.endsWith('QuotaFailure'))
    .flatMap(d => d.violations ?? []);
  const text = `${error.message ?? ''} ${JSON.stringify(violations)}`;
  const zero = violations.some(v => Object.hasOwn(v, 'quotaValue') && String(v.quotaValue) === '0')
    || /\blimit\s*[:=]\s*0\b/i.test(text);
  if (status === 429 && (zero || /per.?day|daily|requestsperday|суточ/i.test(text)))
    return { action: 'stop', floor: 0 };
  if (![429, 503].includes(status)) return { action: 'stop', floor: 0 };
  const floors = [0], value = (headers['retry-after'] ?? '').trim();
  if (/^\d+$/.test(value)) floors.push(Number(value));
  else if (value && Number.isFinite(Date.parse(value)))
    floors.push(Math.max(0, Date.parse(value) / 1000 - now));
  for (const d of details) {
    if (d['@type']?.endsWith('RetryInfo')) {
      const match = /^(\d+(?:\.\d+)?)s$/.exec(d.retryDelay ?? '');
      if (match) floors.push(Number(match[1]));
    }
  }
  return { action: 'retry', floor: Math.max(...floors) };
}
export async function images(body) {
  const found = [];
  for (const c of body.candidates ?? []) for (const p of c.content?.parts ?? []) {
    const b = p.inlineData ?? {}, formats = { 'image/png': 'png', 'image/jpeg': 'jpeg', 'image/webp': 'webp' };
    if (!formats[b.mimeType]) continue;
    if (typeof b.data !== 'string' || !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(b.data))
      throw new Error('Неверный base64');
    const raw = Buffer.from(b.data, 'base64');
    const decoder = sharp(raw), metadata = await decoder.metadata();
    await decoder.raw().toBuffer(); // Декодировать реальные пиксели
    if (metadata.format !== formats[b.mimeType]) throw new Error('MIME не совпадает');
    found.push({ ext: formats[b.mimeType], raw });
  }
  if (!found.length) throw new Error('Нет изображения; проверьте promptFeedback/finishReason');
  return found;
}
async function post(prompt, timeout) {
  if (!process.env.GEMINI_API_KEY) throw new Error('Не задан GEMINI_API_KEY');
  const controller = new AbortController();
  const timer = setTimeout(() => controller.abort(), timeout * 1000);
  try {
    const response = await fetch(url, { method: 'POST', redirect: 'error',
      signal: controller.signal,
      headers: { 'Content-Type': 'application/json', 'x-goog-api-key': process.env.GEMINI_API_KEY },
      body: JSON.stringify({ contents: [{ parts: [{ text: prompt }] }], generationConfig: config }) });
    return [response.status, Object.fromEntries(response.headers), await response.json()];
  } finally { clearTimeout(timer); }
}
export async function run(jobs, directory, opts = {}) {
  const send = opts.send ?? post, clock = opts.clock ?? (() => performance.now() / 1000);
  const wall = opts.wall ?? (() => Date.now() / 1000), sleep = opts.sleep ?? pause;
  const rand = opts.rand ?? Math.random, deadline = clock() + (opts.budget ?? 120);
  await fs.mkdir(directory, { recursive: true });
  const file = path.join(directory, 'state.json');
  let state = {};
  try { state = JSON.parse(await fs.readFile(file, 'utf8')); }
  catch (error) { if (error.code !== 'ENOENT') throw error; }
  const ids = jobs.map(j => j.id);
  if (new Set(ids).size !== ids.length || ids.some(id => !/^[A-Za-z0-9_-]+$/.test(id)))
    throw new Error('Нужны уникальные безопасные id');
  for (const job of jobs) {
    const fingerprint = hash(JSON.stringify([model, config, job.prompt]));
    const record = state[job.id] ??= { fingerprint, attempts: 0 };
    if (record.fingerprint !== fingerprint) throw new Error('Изменённому заданию нужен новый id');
    if (record.status === 'done') {
      for (const f of record.files)
        if (hash(await fs.readFile(path.join(directory, f.name))) !== f.sha256)
          throw new Error('Подтверждённый файл изменён');
      continue;
    }
    if (['inflight', 'unknown', 'stop', 'review'].includes(record.status)) continue;
    while (record.attempts < 4) {
      const wait = Math.max(0, (record.notBefore ?? 0) - wall());
      if (wait + 1 >= deadline - clock()) {
        record.status = 'deferred'; await save(file, state); return state;
      }
      if (wait) await sleep(wait);
      const timeout = Math.min(30, deadline - clock());
      if (timeout < 1) return state;
      record.status = 'inflight'; record.attempts++; await save(file, state);
      let status, headers, body;
      try { [status, headers, body] = await send(job.prompt, timeout); }
      catch { record.status = 'unknown'; await save(file, state); return state; }
      if (status === 200) {
        try {
          const output = await images(body), files = [];
          for (const [i, { ext, raw }] of output.entries()) {
            const name = `${job.id}-${i}.${ext}`, target = path.join(directory, name);
            await fs.writeFile(target + '.tmp', raw); await fs.rename(target + '.tmp', target);
            files.push({ name, sha256: hash(raw) });
          }
          record.status = 'done'; record.files = files;
        } catch { record.status = 'review'; }
        await save(file, state);
        if (record.status !== 'done') return state;
        break;
      }
      const { action, floor } = decision(status, body, headers, wall());
      record.status = action === 'stop' ? 'stop' : 'deferred'; record.http = status;
      if (action === 'retry') record.notBefore = wall() + Math.max(floor, Math.min(16, 2 ** record.attempts) + rand());
      await save(file, state);
      if (action === 'stop' || record.attempts === 4) return state;
    }
  }
  return state;
}
if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
  const jobs = JSON.parse(await fs.readFile(process.argv[2], 'utf8'));
  console.log(JSON.stringify(await run(jobs, process.argv[3]), null, 2));
}