Временные изображения Nano Banana и исправление ошибок: Полное руководство по устранению неполадок 2026

Временные изображения, появляющиеся при вызовах Nano Banana Pro API, не являются багом. Они представляют собой часть встроенного процесса «мышления» Google, при котором модель Gemini 3 Pro Image (gemini-3-pro-image-preview) генерирует до 2 промежуточных изображений для проверки композиции и логики перед созданием финального результата. За промежуточные изображения плата не взимается. Однако многие разработчики путают это нормальное поведение с реальными багами, а у Nano Banana действительно есть настоящие проблемы, которые требуют исправления. В этом руководстве рассматривается всё: объяснение процесса мышления, каждая основная ошибка с решениями, проверенные данные о ценах и готовый для продакшена код обработки ошибок.

Краткое содержание

«Временные изображения» Nano Banana — это функция, а не баг. Процесс мышления модели генерирует до 2 промежуточных изображений перед финальным рендером, и плата за них не взимается. Если вы сталкиваетесь с реальными ошибками, наиболее распространёнными являются 429 RESOURCE_EXHAUSTED (около 70% всех ошибок), ложные срабатывания IMAGE_SAFETY, пустой вывод и несоответствия размеров изображений. В этом руководстве приведены проверенные исправления для каждой проблемы с примерами кода и актуальными данными о ценах по состоянию на февраль 2026 года.

Быстрая диагностика: это баг или нормальное поведение?

Прежде чем приступать к исправлениям, необходимо определить, с какой именно проблемой вы столкнулись. В экосистеме Nano Banana есть как ожидаемые поведения, которые выглядят как баги, так и настоящие проблемы, требующие вмешательства. Правильная диагностика избавит вас от бесполезной траты времени на применение неправильного решения, что является одной из самых распространённых ошибок разработчиков при столкновении с неожиданным поведением API генерации изображений Gemini.

Если вы видите дополнительные изображения перед появлением финального результата, вы почти наверняка наблюдаете процесс мышления в действии. Это абсолютно нормальное поведение для Nano Banana Pro (gemini-3-pro-image-preview), и оно не указывает на проблемы с вашим API-вызовом, промптом или аккаунтом. Модель спроектирована так, чтобы генерировать промежуточные композиции в рамках своего конвейера рассуждений, и в большинстве реализаций SDK эти изображения отфильтровываются перед доставкой финального результата.

Если вы получаете HTTP-коды ошибок вроде 429, 400, 403, 500 или 502, вы имеете дело с настоящими ошибками API, у которых есть конкретные причины и решения. Одна только ошибка 429 RESOURCE_EXHAUSTED составляет примерно 70% всех ошибок Nano Banana API (Google AI Developers Forum, 2026), что делает её наиболее вероятной причиной сбоя вашей интеграции. Каждый код ошибки соответствует конкретной корневой причине, и исправление ошибки лимита запросов кардинально отличается от исправления блокировки фильтром безопасности.

Если ваши API-вызовы успешно завершаются, но не возвращают изображение, или если сгенерированные изображения имеют неправильные размеры, вы столкнулись с другой категорией проблем: тихие сбои и ошибки рендеринга. Их сложнее диагностировать, потому что API не всегда возвращает понятные сообщения об ошибках, а корневые причины варьируются от сложности промпта до временных ограничений инфраструктуры на стороне Google.

Остальная часть этого руководства организована по типам проблем. Перейдите к разделу, соответствующему вашей диагностике, или прочитайте полностью для всестороннего понимания всех известных на данный момент проблем Nano Banana.

Почему вы видите временные изображения при вызовах Nano Banana API

Временные изображения, появляющиеся при вызовах Nano Banana Pro API, представляют собой один из наиболее неправильно понимаемых аспектов архитектуры генерации изображений Google. Вместо того чтобы быть багом или неэффективностью, эти промежуточные изображения являются намеренным архитектурным решением, которое значительно улучшает качество результата для сложных промптов. Понимание того, как работает эта система, поможет вам создавать лучшие интеграции и избежать ошибочных сообщений о нормальном поведении как о баге.

Архитектура процесса мышления

Nano Banana Pro (gemini-3-pro-image-preview) использует то, что Google называет подходом «мыслящей модели» к генерации изображений. В отличие от более простых моделей, которые пытаются отрендерить ваш промпт за один проход, модель Gemini 3 Pro Image использует многоэтапную стратегию рассуждений. Согласно официальной документации Google (проверено в феврале 2026), модель генерирует до 2 промежуточных изображений для проверки композиции и логики перед созданием финального отрендеренного изображения. Последнее изображение в процессе мышления также является финальным результатом, что означает, что модель совершенствует свой подход на каждом шаге, а не отбрасывает и начинает заново.

Режим мышления включён по умолчанию и не может быть отключён через API. Google спроектировал его именно так, потому что улучшение качества за счёт многоэтапного рассуждения является существенным, особенно для промптов, включающих сложные многоэлементные композиции, точный рендеринг текста или детальные пространственные взаимосвязи. Простые промпты вроде «красное яблоко на белом фоне» могут потребовать только одного шага рассуждения, тогда как сложные композиции вроде «интерьер винтажного книжного магазина с тремя читающими людьми, тёплый послеполуденный свет, струящийся через витражные окна, и кот, спящий на прилавке» обычно задействуют полный двухэтапный процесс мышления.

Как обрабатывать временные изображения в коде

Критически важная техническая деталь заключается в том, что временные изображения помечены флагом thought: true в ответе API, тогда как финальное изображение содержит поле thought_signature, которое необходимо сохранять для многоходовых диалогов. Вот как правильно отфильтровывать временные изображения и извлекать только финальный результат на Python:

python
from google import genai

client = genai.Client()
response = client.models.generate_content(
    model="gemini-3-pro-image-preview",
    contents="A professional product photo of wireless headphones on marble"
)


final_images = []
for part in response.candidates[0].content.parts:
    if hasattr(part, 'thought') and part.thought:
        continue  # Skip temporary thinking images
    if hasattr(part, 'inline_data') and part.inline_data:
        final_images.append(part.inline_data)

Поле thought_signature

Одна критически важная деталь, которую многие разработчики упускают: ответ API включает поля thought_signature для частей, не являющихся мыслями. Если вы создаёте многоходовой диалог по редактированию изображений, вы должны передавать эти подписи обратно в последующих запросах. Несоблюдение циклической передачи thought signatures обратно в модель может вызвать ошибки или ухудшение качества вывода в последующих ходах. В официальной документации указано, что «неперенос thought signatures может привести к сбоям ответа», что делает это обязательной деталью реализации, а не необязательной оптимизацией.

Влияние на производительность и тарификация

Процесс мышления добавляет от 5 до 15 секунд задержки к каждой генерации в зависимости от сложности промпта (документация Google AI for Developers, 2026). Простые промпты — на нижней границе, сложные многоэлементные промпты — на верхней. Ключевая деталь тарификации: за временные промежуточные изображения плата не взимается. Вы платите только за финальное отрендеренное изображение. По текущим ценам (проверено в феврале 2026 на ai.google.dev/pricing) Nano Banana Pro стоит $0.134 за изображение в разрешении 1K/2K и $0.24 за изображение в разрешении 4K. Промежуточные изображения мышления не учитываются в этих расходах, поэтому временные изображения, которые вы видите, не увеличивают ваш счёт.

Исправление ошибок IMAGE_SAFETY и фильтров контента

Ошибка IMAGE_SAFETY является одной из самых раздражающих проблем Nano Banana, поскольку она блокирует совершенно легитимные запросы на генерацию изображений. Google публично признал, что их фильтры безопасности «стали гораздо более осторожными, чем мы планировали» (Google AI Developers Forum, 2025), вызывая ложные срабатывания на безобидном контенте, таком как продуктовая фотография, учебные иллюстрации и даже простые запросы вроде «спящий человек» или «собака, играющая в парке».

Почему происходят ложные срабатывания

Фильтр безопасности работает на нескольких уровнях конвейера генерации. Он оценивает как ваш входной промпт, так и сгенерированный вывод, и может сработать на любом из этапов. Это означает, что промпт, прошедший входной фильтр, всё равно может вызвать ошибку IMAGE_SAFETY, если сгенерированное моделью изображение сработает на выходном фильтре. Фильтр использует широкое сопоставление с шаблонами, которое иногда помечает безобидный контент, потому что определённые визуальные элементы или их комбинации напоминают категории, на блокировку которых фильтр обучен. Google выпустил обновление политики в январе 2026 года, скорректировавшее фильтрацию IMAGE_SAFETY и ограничения по известной интеллектуальной собственности, но ложные срабатывания продолжают происходить.

Практические решения, которые работают

Наиболее эффективный подход к устранению ложных срабатываний IMAGE_SAFETY — это переформулировка промпта. Вместо того чтобы бороться с фильтром, используя оригинальную формулировку, перестройте промпт, чтобы предоставить более чёткий контекст, помогающий системе безопасности распознать легитимное намерение. Добавление контекстных слов вроде «профессиональный», «редакционный», «учебный» или «студийная фотография» может сигнализировать фильтру о том, что контент является допустимым. Например, вместо «женщина в платье» попробуйте «профессиональное модное редакционное фото модели в формальном вечернем платье, студийное освещение, стиль модного журнала». Дополнительный контекст даёт системе безопасности больше сигналов для анализа и значительно снижает частоту ложных срабатываний.

Если переформулировка промпта не решает проблему, попробуйте снизить сложность промпта, разбив многоэлементные композиции на более простые запросы. Фильтр безопасности с большей вероятностью помечает сложные промпты, потому что взаимодействие между несколькими элементами создаёт больше неоднозначности для системы сопоставления с шаблонами. Вы также можете попробовать сначала сгенерировать изображение в более низком разрешении (1K вместо 4K), так как поведение фильтра может варьироваться в зависимости от настройки разрешения.

При постоянных проблемах с определёнными категориями контента рассмотрите использование модели Nano Banana (gemini-2.5-flash-image) вместо Nano Banana Pro. Модель Flash Image использует другую конфигурацию фильтра безопасности, которая иногда может обрабатывать промпты, блокируемые моделью Pro, хотя и с более низким качеством вывода. Если вам нужен стабильный доступ к генерации изображений ИИ для вашего приложения без прерываний фильтром безопасности, прокси-сервисы API, такие как laozhang.ai, предлагают альтернативную маршрутизацию, которая может обеспечить более стабильный доступ к этим моделям.

Решение ошибок 429 RESOURCE_EXHAUSTED и лимитов запросов

Ошибка 429 RESOURCE_EXHAUSTED является наиболее распространённой ошибкой Nano Banana API с большим отрывом, составляя примерно 70% всех проблем, с которыми сталкиваются разработчики. Эта ошибка возникает, когда ваши API-запросы превышают лимиты, установленные для уровня вашего аккаунта, и понимание системы уровней необходимо для эффективного управления этой ситуацией.

Как работают лимиты запросов для Nano Banana

Лимиты запросов для Nano Banana измеряются по трём измерениям: запросы в минуту (RPM), токены в минуту (TPM) и запросы в день (RPD). Превышение любого одного лимита вызывает ошибку 429, даже если вы находитесь в пределах остальных двух. Лимиты применяются для каждого проекта (не для каждого API-ключа), а суточные квоты обнуляются в полночь по тихоокеанскому времени. Для моделей генерации изображений Google также отслеживает изображения в минуту (IPM), что функционирует аналогично TPM, но специфично для вывода Nano Banana.

Лимиты запросов существенно различаются по уровням. Система уровней Google (проверено в феврале 2026 на ai.google.dev/gemini-api/docs/rate-limits) имеет четыре уровня: бесплатный уровень (доступен в подходящих регионах), Tier 1 (требует привязки платёжного аккаунта к проекту), Tier 2 (требует суммарных расходов $250+ и 30+ дней с момента первого платежа) и Tier 3 (требует суммарных расходов $1,000+ и 30+ дней). Каждое повышение уровня существенно увеличивает ваши лимиты запросов, при этом превью-модели, такие как Nano Banana Pro, имеют более строгие ограничения, чем стабильные модели.

Подробную разбивку лимитов запросов Gemini API по уровням, включая конкретные значения RPM и RPD для каждой модели, смотрите в нашем полном справочнике по лимитам Gemini API. Если вы конкретно столкнулись с ошибками RESOURCE_EXHAUSTED на Nano Banana, наше подробное руководство по исправлению ошибок Nano Banana RESOURCE_EXHAUSTED предоставляет пошаговые процедуры решения.

Реализация экспоненциальной задержки

Правильный способ обработки ошибок 429 в продакшене — экспоненциальная задержка с джиттером. Вот проверенная реализация на Python, которая обрабатывает наиболее распространённые паттерны сбоев:

python
import time
import random

def generate_with_retry(client, prompt, max_retries=5):
    base_delay = 2
    for attempt in range(max_retries):
        try:
            response = client.models.generate_content(
                model="gemini-3-pro-image-preview",
                contents=prompt
            )
            return response
        except Exception as e:
            if "429" in str(e) or "RESOURCE_EXHAUSTED" in str(e):
                delay = base_delay * (2 ** attempt) + random.uniform(0, 1)
                print(f"Rate limited. Retrying in {delay:.1f}s (attempt {attempt + 1})")
                time.sleep(delay)
            else:
                raise  # Re-raise non-rate-limit errors
    raise Exception("Max retries exceeded for rate limit errors")

Компонент джиттера (случайная добавка) важен, потому что он предотвращает проблему «стада буйволов» (thundering herd), когда несколько клиентов, получивших лимит одновременно, все повторяют запрос в один и тот же момент, вызывая новый раунд ограничений. Типичное время разрешения ошибок 429 составляет от 1 до 5 минут, поэтому при 5 повторах и экспоненциальной задержке эта реализация покрывает большинство кратковременных ситуаций с лимитами.

Исправление сбоев генерации, пустого вывода и ошибок размеров

Помимо лимитов запросов и фильтров безопасности, у Nano Banana есть несколько других режимов сбоев, которые проявляются разными симптомами. Их часто сложнее диагностировать, потому что API может вернуть успешный ответ без данных изображения или вернуть изображение с неправильными размерами. Понимание каждого типа сбоя помогает встроить соответствующую обработку в вашу интеграцию.

Пустой вывод и тихие сбои

Когда Nano Banana возвращает успешный HTTP-ответ, но ответ не содержит данных изображения, вы столкнулись с тихим сбоем. Обычно это происходит по одной из трёх причин. Во-первых, промпт может быть слишком сложным для того, чтобы модель обработала его в рамках своих вычислительных ограничений, особенно для промптов с множеством специфических элементов, которые конфликтуют друг с другом. Во-вторых, внутренняя проверка безопасности модели может пометить сгенерированный вывод после того, как начальная проверка промпта была пройдена, что приводит к успешному API-вызову, но подавленному выводу. В-третьих, временные проблемы с ёмкостью инфраструктуры Google могут вызвать тихий сбой генерации, особенно для запросов в разрешении 4K, которые потребляют значительно больше вычислительных ресурсов.

Диагностический подход при пустом выводе начинается с упрощения промпта. Удалите специфические детали и попробуйте сгенерировать изображение с минимальной версией вашего запроса. Если упрощённый промпт работает, постепенно добавляйте сложность обратно, пока не определите, какой элемент вызывает сбой. При постоянных пустых выводах для всех промптов проверьте Google AI Developers Forum и страницу статуса сервиса Gemini на наличие сообщений о сбоях. Инцидент в январе 2026 года конкретно затронул генерацию в разрешении 4K из-за ограничений ёмкости TPU v7 в сочетании с сессиями обучения Gemini 3.0, потреблявшими ресурсы инференса.

Баги размеров и измерений изображений

Постоянный баг, о котором сообщают множество пользователей на форумах Adobe Community, связан с генерацией Nano Banana изображений с неправильными размерами. Когда пользователи запрашивают модификации существующего изображения (например, изменение цвета волос или корректировку освещения), выходное изображение часто имеет размеры, отличные от входного. Изображение может быть слегка растянуто, сжато, увеличено или смещено в пространственном позиционировании по сравнению с оригиналом. Этот баг затрагивает инструменты Generative Fill и Generate в приложениях, таких как Photoshop Beta, которые используют Nano Banana в качестве бэкенда.

На данный момент у Google нет окончательного исправления бага с размерами. Наиболее эффективный обходной путь — указывать точные выходные размеры в промпте и в параметрах API. При прямом использовании API всегда включайте параметр image_size с явным значением разрешения (1K, 2K или 4K). Для использования через инструменты (Photoshop, Figma) попробуйте работать со стандартными соотношениями сторон из поддерживаемого списка: 1:1, 2:3, 3:2, 3:4, 4:3, 4:5, 5:4, 9:16, 16:9 или 21:9. Нестандартные размеры увеличивают вероятность возникновения бага с размерами.

Серверные ошибки 500/502

Серверные ошибки от Nano Banana API указывают на проблемы на стороне инфраструктуры Google, а не на проблемы с вашим запросом. Эти ошибки обычно разрешаются в течение 5-15 минут без каких-либо действий с вашей стороны. Если серверные ошибки сохраняются более 15 минут, проверьте страницу статуса Gemini API и рассмотрите переключение на модель Nano Banana Flash (gemini-2.5-flash-image) в качестве временного запасного варианта, так как разные модели работают на разной инфраструктуре и могут не быть затронуты одним и тем же сбоем. Для приложений, которые не могут допустить простоя, если вы сравниваете Nano Banana Pro с альтернативами вроде Flux 2, наличие настроенной запасной модели является рекомендуемой практикой для продакшена.

Цены на Nano Banana: взимается ли плата за временные изображения?

Один из самых распространённых вопросов разработчиков, столкнувшихся с временными изображениями, — взимается ли плата за эти промежуточные результаты. Окончательный ответ, проверенный непосредственно на странице цен Google AI for Developers в феврале 2026 года: нет, за временные промежуточные изображения плата не взимается. Вы платите только за финальное отрендеренное изображение.

Официальная структура цен

Вот полная структура цен для обеих моделей Nano Banana, проверенная на ai.google.dev/pricing 9 февраля 2026 года:

Тарификация вывода изображений работает на основе токенов. Для Nano Banana Pro изображение 1K или 2K потребляет 1120 токенов по ставке $120/M, что равно $0.134 за изображение. Изображение 4K потребляет 2000 токенов, что равно $0.24 за изображение. Для Nano Banana Flash максимальное разрешение составляет 1K (1024x1024), потребляя 1290 токенов по ставке $30/M, что равно $0.039 за изображение. Ввод изображения тарифицируется по 560 токенов на изображение (приблизительно $0.0011 за входное изображение для Pro).

Ни одна из моделей в настоящее время не предлагает бесплатный уровень для генерации изображений. Обе требуют платного биллингового аккаунта. Однако текстовые взаимодействия с этими моделями могут по-прежнему подпадать под бесплатный тариф их родительских моделей (Gemini 3 Pro и Gemini 2.5 Flash соответственно).

Стратегии оптимизации затрат

Для задач генерации изображений в больших объёмах несколько стратегий могут значительно снизить расходы. Использование Nano Banana Flash ($0.039/изображение) вместо Pro ($0.134/изображение) для задач, не требующих разрешения 2K/4K или сложного рассуждения, экономит около 71% за изображение. Для приложений, которым необходимо качество Pro, но при меньших затратах, прокси-сервисы API, такие как laozhang.ai, предлагают доступ к Nano Banana Pro примерно по $0.05 за изображение (около 63% экономии по сравнению с прямой ценой API), что делает использование больших объёмов в продакшене более экономичным.

Для подробных сравнений цен, включая бенчмарки скорости, смотрите наши бенчмарки цен и скорости Gemini 3 Pro Image API и руководство по бесплатному уровню Gemini API.

Создание надёжной обработки ошибок для Nano Banana API

Продакшен-приложения, зависящие от Nano Banana для генерации изображений, нуждаются в комплексной обработке ошибок, учитывающей каждый режим сбоя, рассмотренный в этом руководстве. Следующие паттерны, основанные на реальном опыте продакшена, предоставляют основу для построения надёжных интеграций, которые корректно деградируют при возникновении проблем.

Комплексный обработчик ошибок

Вот паттерн обработки ошибок, готовый к продакшену, который покрывает все основные режимы сбоев Nano Banana:

python
import time
import random
from enum import Enum

class NanaBananaError(Enum):
    RATE_LIMIT = "429"
    SAFETY = "IMAGE_SAFETY"
    SERVER = "500"
    BAD_GATEWAY = "502"
    BLANK_OUTPUT = "BLANK"
    UNKNOWN = "UNKNOWN"

def classify_error(error):
    error_str = str(error)
    if "429" in error_str or "RESOURCE_EXHAUSTED" in error_str:
        return NanaBananaError.RATE_LIMIT
    elif "IMAGE_SAFETY" in error_str or "safety" in error_str.lower():
        return NanaBananaError.SAFETY
    elif "500" in error_str:
        return NanaBananaError.SERVER
    elif "502" in error_str:
        return NanaBananaError.BAD_GATEWAY
    return NanaBananaError.UNKNOWN

def generate_image(client, prompt, model="gemini-3-pro-image-preview",
                   max_retries=5, fallback_model="gemini-2.5-flash-image"):
    for attempt in range(max_retries):
        try:
            response = client.models.generate_content(
                model=model, contents=prompt
            )
            # Check for blank output
            images = [p for p in response.candidates[0].content.parts
                     if hasattr(p, 'inline_data') and p.inline_data
                     and not getattr(p, 'thought', False)]
            if not images:
                if attempt < max_retries - 1:
                    time.sleep(2)
                    continue
                raise Exception("Blank output after all retries")
            return images
        except Exception as e:
            error_type = classify_error(e)
            if error_type == NanaBananaError.RATE_LIMIT:
                delay = 2 * (2 ** attempt) + random.uniform(0, 1)
                time.sleep(delay)
            elif error_type == NanaBananaError.SAFETY:
                raise  # Cannot retry safety errors with same prompt
            elif error_type in (NanaBananaError.SERVER, NanaBananaError.BAD_GATEWAY):
                if attempt == max_retries - 2:
                    model = fallback_model  # Switch to fallback on last retry
                time.sleep(5 * (attempt + 1))
            else:
                raise
    raise Exception(f"Failed after {max_retries} attempts")

Эта реализация обрабатывает полный спектр ошибок: экспоненциальная задержка для лимитов запросов, немедленный сбой для ошибок безопасности (поскольку повторная попытка с тем же промптом даст тот же результат), прогрессивные задержки для серверных ошибок с автоматическим переключением на модель Flash, а также обнаружение пустого вывода с логикой повторных попыток. Переключение на запасную модель при предпоследней попытке обеспечивает последний резервный путь, который позволяет вашему приложению продолжать генерировать изображения, даже когда Pro испытывает проблемы с инфраструктурой.

Рекомендации по мониторингу и оповещениям

Для продакшен-развёртываний отслеживайте следующие метрики: частоту ошибок по типам (429 vs SAFETY vs 500), среднюю задержку генерации (включая время мышления), частоту пустого вывода и стоимость за успешную генерацию. Настройте оповещения, когда частота ошибок 429 превышает 10% от общего числа запросов (что указывает на приближение к лимитам вашего уровня) или когда частота серверных ошибок превышает 5% (что указывает на возможный сбой на стороне Google). Google рекомендует проверять ваши эффективные лимиты запросов в панели использования AI Studio, которая показывает потребление квоты в реальном времени и оставшуюся ёмкость.

Часто задаваемые вопросы

Почему Nano Banana генерирует 2 лишних изображения перед показом финального результата?

Это «изображения мышления», генерируемые процессом мышления модели Gemini 3 Pro Image. Модель использует многоэтапное рассуждение для проверки композиции и улучшения качества перед созданием финального результата. Это ожидаемое поведение, а не баг, и за временные изображения плата не взимается.

Взимается ли плата за временные изображения мышления?

Нет. Согласно официальной странице цен Google AI (проверено в феврале 2026 года), оплачивается только финальное отрендеренное изображение. За изображения мышления, генерируемые в процессе рассуждения, плата не взимается. Для Nano Banana Pro стоимость составляет $0.134 за изображение 1K/2K и $0.24 за изображение 4K.

Можно ли отключить процесс мышления для более быстрых результатов?

Нет. Режим мышления включён по умолчанию и не может быть отключён через API. Google спроектировал его именно так, потому что улучшение качества оправдывает увеличение задержки на 5-15 секунд. Если вам нужна более быстрая генерация без мышления, используйте модель Nano Banana Flash (gemini-2.5-flash-image), которая не использует такое же многоэтапное рассуждение.

Что вызывает ошибку IMAGE_SAFETY на совершенно безопасных промптах?

Фильтры безопасности Google используют широкое сопоставление с шаблонами, которое может давать ложные срабатывания. Google признал, что фильтры «стали гораздо более осторожными, чем планировалось». Попробуйте переформулировать промпт, добавив профессиональный контекст, снизить сложность или использовать более низкое разрешение.

Почему сгенерированные изображения имеют размеры, отличные от входного?

Это известный баг с размерами, затрагивающий Nano Banana в таких приложениях, как Photoshop Beta и Figma. Обходной путь — явно указывать размеры, используя поддерживаемые соотношения сторон (1:1, 2:3, 3:2, 3:4, 4:3, 4:5, 5:4, 9:16, 16:9, 21:9) и параметры разрешения (1K, 2K, 4K) в ваших API-вызовах.