invoke-ai/InvokeAI · error · ExternalProviderCapabilityError

{request.model.name} supports a maximum size of {capabilitie

Error message

{request.model.name} supports a maximum size of {capabilities.max_image_size.width}x{capabilities.max_image_size.height}

What it means

ExternalProviderCapabilityError raised by _validate_request when request.width or request.height exceeds capabilities.max_image_size dimensions. The requested output resolution is larger than the external model allows.

Source

Thrown at invokeai/app/services/external_generation/external_generation_default.py:124

            raise ExternalProviderCapabilityError(f"Mode '{request.mode}' is not supported by {request.model.name}")

        if request.reference_images and not capabilities.supports_reference_images:
            raise ExternalProviderCapabilityError(f"Reference images are not supported by {request.model.name}")

        if capabilities.max_reference_images is not None:
            if len(request.reference_images) > capabilities.max_reference_images:
                raise ExternalProviderCapabilityError(
                    f"{request.model.name} supports at most {capabilities.max_reference_images} reference images"
                )

        if capabilities.max_images_per_request is not None and request.num_images > capabilities.max_images_per_request:
            raise ExternalProviderCapabilityError(
                f"{request.model.name} supports at most {capabilities.max_images_per_request} images per request"
            )

        if capabilities.max_image_size is not None:
            if request.width > capabilities.max_image_size.width or request.height > capabilities.max_image_size.height:
                raise ExternalProviderCapabilityError(
                    f"{request.model.name} supports a maximum size of {capabilities.max_image_size.width}x{capabilities.max_image_size.height}"
                )

        if capabilities.allowed_aspect_ratios:
            aspect_ratio = _format_aspect_ratio(request.width, request.height)
            if aspect_ratio not in capabilities.allowed_aspect_ratios:
                size_ratio = None
                if capabilities.aspect_ratio_sizes:
                    size_ratio = _ratio_for_size(request.width, request.height, capabilities.aspect_ratio_sizes)
                if size_ratio is None or size_ratio not in capabilities.allowed_aspect_ratios:
                    ratio_label = size_ratio or aspect_ratio
                    raise ExternalProviderCapabilityError(
                        f"{request.model.name} does not support aspect ratio {ratio_label}"
                    )

        required_modes = capabilities.input_image_required_for or ["img2img", "inpaint"]
        if request.mode in required_modes and request.init_image is None:
            raise ExternalProviderCapabilityError(

View on GitHub (pinned to 0b6a024f2f)

Solutions

Clamp width/height to the model's max_image_size, preserving aspect ratio
Generate at an allowed size and upscale locally afterwards
Choose a model with a higher max_image_size
Update UI size presets from model capabilities before submitting

Example fix

// before
request.width, request.height = 2048, 2048  # max is 1024x1024

// after
mx = model.capabilities.max_image_size
scale = min(1.0, mx.width / request.width, mx.height / request.height)
request.width, request.height = int(request.width * scale), int(request.height * scale)

Defensive patterns

Strategy: validation

Validate before calling

mx = request.model.capabilities.max_image_size
if mx is not None:
    scale = min(1.0, mx.width / request.width, mx.height / request.height)
    request.width = int(request.width * scale)
    request.height = int(request.height * scale)

Type guard

def within_max_size(model, width: int, height: int) -> bool:
    mx = model.capabilities.max_image_size
    return mx is None or (width <= mx.width and height <= mx.height)

Try / catch

try:
    result = service.generate(request)
except ExternalProviderCapabilityError as e:
    if "maximum size" in str(e):
        mx = request.model.capabilities.max_image_size
        s = min(mx.width / request.width, mx.height / request.height)
        request.width, request.height = int(request.width * s), int(request.height * s)
        result = service.generate(request)
    else:
        raise

Prevention

Clamp size inputs to the model's max_image_size before submit
Preserve aspect ratio when downscaling to fit the cap
Update canvas size presets from the selected model's capabilities
Plan for local upscaling instead of requesting oversized generations

When it happens

Trigger: generate() called where request.width > capabilities.max_image_size.width or request.height > capabilities.max_image_size.height.

Common situations: Reusing high-res settings (e.g. 2048px) with a model capped at 1024px; aspect-ratio presets producing a dimension above the cap; upscaling settings applied to a non-upscaling external model.

Related errors

AI-assisted analysis of invoke-ai/InvokeAI@0b6a024f2f (2026-08-29). Data as JSON: /api/errors/26cecf3fc6c90bcf. Report an issue: GitHub.