Nano Banana ProのRESOURCE_EXHAUSTEDの対処：再試行と画像ジョブの再開

python -m pip install httpx Pillow
python recover.py prompt.txt jobs-python

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

MODEL = 'gemini-3-pro-image'
BUDGET, CALL_LIMIT, ATTEMPTS = 150.0, 45.0, 4

def decision(status, headers, body):
    error = body.get('error', {}) if isinstance(body, dict) else {}
    details = error.get('details', [])
    floors = [0.0]
    raw = headers.get('Retry-After', headers.get('retry-after', ''))
    if re.fullmatch(r'\d+', str(raw)):
        floors.append(float(raw))
    elif raw:
        try:
            floors.append(max(0, parsedate_to_datetime(raw).timestamp() - time.time()))
        except (ValueError, TypeError, OverflowError):
            pass
    blocked = status not in (429, 503)
    for d in details:
        kind = d.get('@type', '')
        if kind.endswith('RetryInfo'):
            delay = d.get('retryDelay', '')
            if re.fullmatch(r'\d+(?:\.\d+)?s', delay):
                floors.append(float(delay[:-1]))
        if kind.endswith('QuotaFailure'):
            for v in d.get('violations', []):
                label = ' '.join(str(v.get(k, '')) for k in
                                 ('quotaId', 'quotaMetric', 'description')).lower()
                zero = 'quotaValue' in v and str(v['quotaValue']) == '0'
                daily = bool(re.search(r'per.?day|daily|\brpd\b', label))
                disabled = bool(re.search(r'service.?disabled', label))
                blocked = blocked or zero or daily or disabled
    # Missing quotaValue is deliberately not interpreted as zero.
    if re.search(r'\blimit\s*[:=]\s*0\b', error.get('message', ''), re.I):
        blocked = True
    return ('blocked' if blocked else 'retry'), max(floors)

def picture(body):
    for c in body.get('candidates', []):
        for p in c.get('content', {}).get('parts', []):
            inline = p.get('inlineData', {})
            if p.get('thought') or not inline.get('mimeType', '').startswith('image/'):
                continue
            data = base64.b64decode(inline.get('data', ''), validate=True)
            with Image.open(io.BytesIO(data)) as im:
                im.load()
                out = io.BytesIO()
                im.save(out, format='PNG')
                return out.getvalue()
    raise ValueError('HTTP 200 but no final, decodable image')

def store(path, state):
    tmp = path.with_suffix('.tmp')
    tmp.write_text(json.dumps(state, ensure_ascii=False), encoding='utf-8')
    tmp.replace(path)

async def recover(prompt, folder, key, post=None, clock=time.monotonic,
                  sleep=asyncio.sleep):
    request = {'contents': [{'parts': [{'text': prompt}]}],
               'generationConfig': {'responseModalities': ['TEXT', 'IMAGE'],
                 'imageConfig': {'aspectRatio': '16:9', 'imageSize': '1K'}}}
    identity = hashlib.sha256(json.dumps([MODEL, request], sort_keys=True).encode()).hexdigest()
    folder.mkdir(parents=True, exist_ok=True)
    path, image = folder / (identity + '.json'), folder / (identity + '.png')
    state = json.loads(path.read_text()) if path.exists() else {'status': 'pending'}
    if state['status'] == 'done':
        if not image.exists() or hashlib.sha256(image.read_bytes()).hexdigest() != state['sha256']:
            raise RuntimeError('Saved image missing or changed; do not regenerate automatically')
        return str(image)
    if state['status'] in ('sending', 'unknown', 'blocked', 'no_image'):
        raise RuntimeError('Inspect saved job before explicitly permitting a new request')
    if state.get('not_before', 0) > time.time():
        return 'deferred: server minimum has not elapsed'
    started = clock()
    async with httpx.AsyncClient() as session:
        async def live(timeout):
            url = f'https://generativelanguage.googleapis.com/v1beta/models/{MODEL}:generateContent'
            r = await session.post(url, json=request, headers={'x-goog-api-key': key},
                                   timeout=timeout)
            return r.status_code, dict(r.headers), r.json()
        send = post or live
        for attempt in range(ATTEMPTS):
            remaining = BUDGET - (clock() - started)
            if remaining <= 0:
                break
            state = {'status': 'sending', 'attempt': attempt + 1}
            store(path, state)
            try:
                status, headers, body = await asyncio.wait_for(
                    send(min(CALL_LIMIT, remaining)), timeout=min(CALL_LIMIT, remaining))
            except Exception:
                store(path, {'status': 'unknown'})
                raise RuntimeError('Unconfirmed POST result; automatic retry stopped') from None
            if status == 200:
                try:
                    data = picture(body)
                except Exception:
                    store(path, {'status': 'no_image', 'response': body})
                    raise RuntimeError('Response saved; inspect blocked/text/invalid-image result') from None
                temporary = image.with_suffix('.png.tmp')
                temporary.write_bytes(data)
                temporary.replace(image)
                store(path, {'status': 'done', 'sha256': hashlib.sha256(data).hexdigest(),
                             'responseId': body.get('responseId')})
                return str(image)
            action, minimum = decision(status, headers, body)
            if action == 'blocked':
                store(path, {'status': 'blocked', 'http': status, 'error': body})
                return f'blocked: HTTP {status}'
            delay = max(minimum, min(2 ** (attempt + 1), 30)) + random.uniform(0, 1)
            state = {'status': 'pending', 'not_before': time.time() + delay,
                     'http': status, 'error': body}
            store(path, state)
            remaining = BUDGET - (clock() - started)
            if attempt + 1 == ATTEMPTS or delay + 1 >= remaining:
                return 'deferred: inspect state and resume after not_before'
            await sleep(delay)
        return 'deferred: cumulative time budget exhausted'

if __name__ == '__main__':
    prompt = Path(sys.argv[1]).read_text(encoding='utf-8')
    key = os.environ['GEMINI_API_KEY']
    print(asyncio.run(recover(prompt, Path(sys.argv[2]), key)))

npm install sharp
node recover.mjs prompt.txt jobs-node

import { promises as fs } from 'node:fs';
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 budgetMs = 150000, callMs = 45000, attempts = 4;
const hash = bytes => createHash('sha256').update(bytes).digest('hex');
const pause = ms => new Promise(resolve => setTimeout(resolve, ms));

export function inspect(status, headers, body) {
  const error = body?.error ?? {};
  let stop = ![429, 503].includes(status), minimum = 0;
  const after = headers['retry-after'];
  if (/^\d+$/.test(after ?? '')) minimum = Number(after) * 1000;
  else if (after && Number.isFinite(Date.parse(after)))
    minimum = Math.max(0, Date.parse(after) - Date.now());
  for (const detail of error.details ?? []) {
    if (detail['@type']?.endsWith('RetryInfo') &&
        /^\d+(\.\d+)?s$/.test(detail.retryDelay ?? ''))
      minimum = Math.max(minimum, Number(detail.retryDelay.slice(0, -1)) * 1000);
    if (detail['@type']?.endsWith('QuotaFailure')) {
      for (const violation of detail.violations ?? []) {
        const label = ['quotaId', 'quotaMetric', 'description']
          .map(k => violation[k] ?? '').join(' ');
        stop ||= (Object.hasOwn(violation, 'quotaValue') &&
                  String(violation.quotaValue) === '0') ||
                 /per.?day|daily|\brpd\b|service.?disabled/i.test(label);
      }
    }
  }
  stop ||= /\blimit\s*[:=]\s*0\b/i.test(error.message ?? '');
  return { stop, minimum };
}

export async function finalImage(body) {
  for (const candidate of body.candidates ?? []) {
    for (const part of candidate.content?.parts ?? []) {
      const blob = part.inlineData;
      if (part.thought || !blob?.mimeType?.startsWith('image/')) continue;
      const encoded = blob.data;
      if (typeof encoded !== 'string' || !encoded.length || encoded.length % 4 ||
          !/^[A-Za-z0-9+/]*={0,2}$/.test(encoded)) throw Error('Invalid base64');
      return await sharp(Buffer.from(encoded, 'base64')).png().toBuffer();
    }
  }
  throw Error('HTTP 200 without a final image');
}

async function save(file, record) {
  await fs.writeFile(file + '.tmp', JSON.stringify(record));
  await fs.rename(file + '.tmp', file);
}

export async function runJob(prompt, directory, key, options = {}) {
  const clock = options.clock ?? (() => performance.now());
  const sleep = options.sleep ?? pause;
  const request = {
    contents: [{ parts: [{ text: prompt }] }],
    generationConfig: { responseModalities: ['TEXT', 'IMAGE'],
      imageConfig: { aspectRatio: '16:9', imageSize: '1K' } }
  };
  const id = hash(JSON.stringify({ model, request }));
  await fs.mkdir(directory, { recursive: true });
  const record = path.join(directory, id + '.json');
  const output = path.join(directory, id + '.png');
  let state;
  try { state = JSON.parse(await fs.readFile(record, 'utf8')); }
  catch (error) {
    if (error.code !== 'ENOENT') throw error;
    state = { status: 'pending' };
  }
  if (state.status === 'done') {
    const bytes = await fs.readFile(output);
    if (hash(bytes) !== state.sha256) throw Error('Saved result changed; inspect it');
    return output;
  }
  if (['sending', 'unknown', 'blocked', 'no_image'].includes(state.status))
    throw Error('Inspect job before explicitly permitting another POST');
  if ((state.notBefore ?? 0) > Date.now()) return 'deferred: wait until notBefore';
  const started = clock();
  const post = options.post ?? (async timeout => {
    const response = await fetch(
      `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent`,
      { method: 'POST', headers: { 'x-goog-api-key': key,
          'Content-Type': 'application/json' }, body: JSON.stringify(request),
        signal: AbortSignal.timeout(Math.max(1, Math.floor(timeout))) });
    return { status: response.status, headers: Object.fromEntries(response.headers),
      body: await response.json() };
  });
  for (let attempt = 1; attempt <= attempts; attempt++) {
    const remaining = budgetMs - (clock() - started);
    if (remaining <= 0) break;
    await save(record, { status: 'sending', attempt });
    let response;
    try { response = await post(Math.min(callMs, remaining)); }
    catch {
      await save(record, { status: 'unknown' });
      throw Error('POST outcome unknown; automatic retry stopped');
    }
    if (response.status === 200) {
      let bytes;
      try { bytes = await finalImage(response.body); }
      catch {
        await save(record, { status: 'no_image', response: response.body });
        throw Error('Inspect saved response; no decodable final image');
      }
      await fs.writeFile(output + '.tmp', bytes);
      await fs.rename(output + '.tmp', output);
      await save(record, { status: 'done', sha256: hash(bytes),
        responseId: response.body.responseId });
      return output;
    }
    const { stop, minimum } = inspect(response.status, response.headers, response.body);
    if (stop) {
      await save(record, { status: 'blocked', http: response.status, error: response.body });
      return `blocked: HTTP ${response.status}`;
    }
    const wait = Math.max(minimum, Math.min(2 ** attempt * 1000, 30000)) +
                 Math.random() * 1000;
    await save(record, { status: 'pending', notBefore: Date.now() + wait,
      http: response.status, error: response.body });
    if (attempt === attempts || wait + 1000 >= budgetMs - (clock() - started))
      return 'deferred: inspect state and resume after notBefore';
    await sleep(wait);
  }
  return 'deferred: cumulative time budget exhausted';
}

if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
  const prompt = await fs.readFile(process.argv[2], 'utf8');
  if (!process.env.GEMINI_API_KEY) throw Error('GEMINI_API_KEY is required');
  console.log(await runJob(prompt, process.argv[3], process.env.GEMINI_API_KEY));
}