calesthio/OpenMontage · error · ValueError

{spec['family']} does not expose operation={operation!r}, va

Error message

{spec['family']} does not expose operation={operation!r}, variant={variant!r} on Atlas Cloud

What it means

Raised by AtlasVideoTool._resolve_model when the requested model family exists in VIDEO_MODELS but VIDEO_ROUTES[family] has no entry for the composed route key (operation, or f"{operation}_{variant}" when variant != 'standard'). It means the model id is known but that operation/variant pairing has no mapped Atlas Cloud endpoint.

Source

Thrown at tools/video/atlas_video.py:197

        return round(rate * max(duration, 0), 4)

    def estimate_runtime(self, inputs: dict[str, Any]) -> float:
        return 180.0

    def is_operation_available(self, operation: str) -> bool:
        return operation in _OPERATIONS

    def _resolve_model(self, model: str, operation: str, variant: str | None = None) -> str:
        if model not in VIDEO_MODELS:
            raise ValueError(
                f"Unsupported Atlas video model id {model!r}. Use get_info()['model_catalog'] for live routes."
            )
        spec = VIDEO_MODELS[model]
        variant = variant or str(spec.get("variant", "standard"))
        route_key = operation if variant == "standard" else f"{operation}_{variant}"
        resolved = VIDEO_ROUTES.get(spec["family"], {}).get(route_key)
        if not resolved:
            raise ValueError(
                f"{spec['family']} does not expose operation={operation!r}, variant={variant!r} on Atlas Cloud"
            )
        return resolved

    @staticmethod
    def _validate_choice(name: str, value: Any, allowed: tuple[Any, ...] | None) -> Any:
        if allowed and value not in allowed:
            raise ValueError(f"{name}={value!r} is not supported; choose one of {list(allowed)}")
        return value

    def _build_payload(self, inputs: dict[str, Any], model: str) -> dict[str, Any]:
        spec = VIDEO_MODELS[model]
        payload: dict[str, Any] = {"model": model, "prompt": inputs.get("prompt", "")}

        if spec["operation"] != "video_edit":
            duration = int(inputs.get("duration", 10))
            payload["duration"] = self._validate_choice("duration", duration, spec["durations"])
            ratio = inputs.get("aspect_ratio", spec["default_ratio"])

View on GitHub (pinned to 95e1c3d0ab)

Solutions

1. Check the live catalog: call get_info()['model_catalog'] and confirm the operation/variant pair is listed for that family
2. Drop the variant argument (it defaults to spec['variant'] or 'standard') or set variant='standard'
3. Switch to a model whose family is documented to expose the operation you need (e.g. a seedance family for reference-conditioned video)
4. If you believe the route should exist, update VIDEO_ROUTES for the family and add a test; do not hardcode the resolved endpoint

Example fix

# before
result = atlas_video.run(inputs={'model':'minimax/h3','prompt':'...','operation':'video_edit'})

# after
info = atlas_video.get_info()
# pick a family whose routes include video_edit from info['model_catalog']
result = atlas_video.run(inputs={'model':'google/gemini-omni-flash','prompt':'...','operation':'video_edit','video_url':vid})

# before calling atlas_video
info = atlas_video.get_info()
spec = info['model_catalog'].get(model)
assert spec is not None, f'unknown model {model}'
family = spec['family']
variant = variant or spec.get('variant', 'standard')
route_key = operation if variant == 'standard' else f'{operation}_{variant}'
assert route_key in info['routes'].get(family, {}), f'{family} lacks {route_key}'

def atlas_route_exists(catalog: dict, model: str, operation: str, variant: str | None = None) -> bool:
    spec = catalog.get('model_catalog', {}).get(model)
    if not spec:
        return False
    key = operation if (variant or spec.get('variant', 'standard')) == 'standard' else f"{operation}_{variant}"
    return key in catalog.get('routes', {}).get(spec['family'], {})

try:
    result = atlas_video.run(inputs=inputs)
except ValueError as e:
    if 'does not expose operation' in str(e):
        catalog = atlas_video.get_info()['model_catalog']
        raise SystemExit(f'pick a model exposing {operation}: {catalog}') from e
    raise

When it happens

Trigger: Calling atlas_video with a model whose family lacks the requested operation (e.g. image_to_video on a text-only model), or passing variant='pro'/'turbo' when VIDEO_ROUTES defines only the standard route for that family. Route key is built as operation if variant=='standard' else operation_variant, so a typo in either component also lands here.

Common situations: Assuming every Atlas model supports every operation; passing a variant that only exists for a different family; stale VIDEO_ROUTES mapping after Atlas adds/renames endpoints; copy-pasting a tool call from one model to another.

Related errors

• {name}={value!r} is not supported; choose one of {list(allow
• image_to_video requires image_url, image_path, or reference_
• This Gemini route requires at least one reference image
• reference_to_video requires supported reference media for th
• {model} accepts at most {limits['images']} images, {limits['

AI-assisted analysis of calesthio/OpenMontage@95e1c3d0ab (2026-08-15). Data as JSON: /api/errors/a4d04e1a0e5015a5. Report an issue: GitHub.