unslothai/unsloth · error · ValueError

'{repo_id}' is not a supported text-to-video model. Supporte

Error message

'{repo_id}' is not a supported text-to-video model. Supported families: {', '.join(supported_video_family_names())}. If this is a variant of one of them, pass family_override with that family name.

What it means

Family detection (_detect_load_family over repo id, GGUF arch, and family_override) returned None: the requested repo is not recognized as any supported text-to-video family. The message lists supported family names and points variants at family_override. This is the network-free first gate, raised before any diffusers import or download.

Source

Thrown at studio/backend/core/inference/video.py:1076

        gguf_filename: Optional[str] = None,
        base_repo: Optional[str] = None,
        family_override: Optional[str] = None,
        model_kind: Optional[str] = None,
        transformer_quant: Optional[str] = None,
        text_encoder_quant: Optional[str] = None,
        h3_task: Optional[str] = None,
    ) -> VideoFamily:
        """Cheap, network-free validation shared by the route and the load path."""
        kind = resolve_video_model_kind(gguf_filename, model_kind)
        # A -GGUF repo picked without a quant filename resolves to pipeline kind and would only fail in from_pretrained after eviction.
        if kind == "pipeline" and repo_id.strip().lower().rstrip("/").endswith("-gguf"):
            raise ValueError(
                f"'{repo_id}' is a GGUF repo: pick one of its .gguf files "
                "(gguf_filename) instead of loading it as a diffusers pipeline."
            )
        fam = _detect_load_family(repo_id, gguf_filename, family_override)
        if fam is None:
            raise ValueError(
                f"'{repo_id}' is not a supported text-to-video model. Supported families: "
                f"{', '.join(supported_video_family_names())}. If this is a variant of one "
                f"of them, pass family_override with that family name."
            )
        # ── modular-workflow refusals, before anything heavier.
        # Deliberately the FIRST thing after the family resolves: everything below reaches into
        # diffusers (assert_pipeline_class_available, the transformer_class probe), so a refusal
        # placed after them would be unreachable on any install whose diffusers cannot even be
        # imported -- and these two are exactly the picks that cost the most to discover late.
        if fam.modular_workflow and kind == "single_file":
            # A modular workflow has no single-file assembly: its components each load through
            # their own from_pretrained from the modular index, and nothing consumes a lone
            # .safetensors DiT. Today that only surfaces inside the loader, i.e. after ~98.7 GB
            # has downloaded AND after the resident pipeline was torn down to make room for it.
            gguf_hint = (
                f", or a .gguf checkpoint from '{fam.gguf_repo}' for a quantized single-file load"
                if fam.gguf_repo
                else ""

View on GitHub (pinned to 203007d190)

Solutions

Use one of the supported family repos named in the error message.
If the repo is a genuine variant of a supported family, pass family_override with that family name.
For GGUF repos with unusual filenames, pass model_kind='gguf' plus gguf_filename so the arch detection has the right input.
Update the backend — newly supported families are added over time.

Example fix

# before
load_video_model(repo_id='some-org/new-video-model')

# after
load_video_model(repo_id='some-org/new-video-model', family_override='hunyuan-video')  # if truly a variant
# or use a supported repo:
load_video_model(repo_id='hunyuanvideo-community/hunyuanvideo-1.5-diffusers-720p_t2v')

Defensive patterns

Strategy: validation

Validate before calling

from core.inference.video import _detect_load_family, resolve_video_model_kind

def repo_supported(repo_id, gguf_filename=None, family_override=None) -> bool:
    return _detect_load_family(repo_id, gguf_filename, family_override) is not None

Try / catch

try:
    load_video_model(repo_id=r)
except ValueError as e:
    if 'not a supported text-to-video model' in str(e):
        load_video_model(repo_id=r, family_override=guess_variant_family(r))
    else:
        raise

Prevention

Offer only supported family repos in the model picker.
For genuine variants, pass family_override with the base family name rather than editing repo ids.
Re-check support after backend updates; family lists grow over time.

When it happens

Trigger: Passing a repo_id (with optional gguf_filename/family_override) that matches none of the supported video families — an image model id, a renamed mirror, a brand-new model the backend predates, or a typo in the repo id.

Common situations: Trying an image-diffusion repo on the video route; using a quantizer's renamed GGUF repo whose arch tag the detector does not know; version skew after a new family ships upstream but the installed backend is older; typos like 'hunyuanvideo-communiy'.

Related errors

AI-assisted analysis of unslothai/unsloth@203007d190 (2026-08-15). Data as JSON: /api/errors/d48bc45ad1ae105a. Report an issue: GitHub.