sgl-project/sglang · error · ValueError

Unsupported module payload type for load_format={load_format

Error message

Unsupported module payload type for load_format={load_format}: {type(module_payload).__name__}

What it means

Raised by WeightsUpdater._materialize_weights_iter when the module payload is neither a flattened_bucket dict nor a list/tuple. Only lists and tuples (or the special bucket format) can be iterated into weight tensors.

Source

Thrown at python/sglang/multimodal_gen/runtime/post_training/weights_updater.py:783

    def _materialize_weights_iter(self, module_payload: Any, load_format: str | None):
        if load_format == "flattened_bucket":
            if not isinstance(module_payload, dict):
                raise ValueError(
                    "flattened_bucket payload must be a dict with "
                    "'flattened_tensor' and 'metadata'."
                )
            flattened_tensor = module_payload.get("flattened_tensor")
            metadata = module_payload.get("metadata")
            if flattened_tensor is None or metadata is None:
                raise ValueError(
                    "flattened_bucket payload missing 'flattened_tensor' or 'metadata'."
                )
            return self._reconstruct_from_flattened_bucket(flattened_tensor, metadata)

        if isinstance(module_payload, (list, tuple)):
            return iter(module_payload)

        raise ValueError(
            f"Unsupported module payload type for load_format={load_format}: "
            f"{type(module_payload).__name__}"
        )

    def _reconstruct_from_flattened_bucket(self, flattened_tensor: Any, metadata: Any):
        if not isinstance(flattened_tensor, torch.Tensor):
            raise ValueError(
                "flattened_bucket 'flattened_tensor' must be a torch.Tensor."
            )
        if not isinstance(metadata, list):
            raise ValueError("flattened_bucket 'metadata' must be a list.")

        converted_metadata: list[FlattenedTensorMetadata] = []
        for meta in metadata:
            converted_metadata.append(
                FlattenedTensorMetadata(
                    name=meta.name,
                    shape=torch.Size(meta.shape),

View on GitHub (pinned to 0132848349)

Solutions

1. Convert to a list/tuple of tensors: list(payload.values()) for a state_dict
2. For single-tensor modules, wrap it: [tensor]
3. Use the flattened_bucket format with a proper bucket dict

Example fix

// before
updater.update_weights_from_tensor(named_tensors=some_generator)
// after
updater.update_weights_from_tensor(named_tensors=list(some_generator))

from collections.abc import Iterable
p = list(p) if not isinstance(p, (list, tuple)) else p

def is_materializable(p: Any, load_format: str | None) -> bool:
    return isinstance(p, (list, tuple)) or (load_format == "flattened_bucket" and isinstance(p, dict))

When it happens

Trigger: update_weights_from_tensor with a payload that is a single torch.Tensor, a generator, a dict of named tensors (without load_format='flattened_bucket'), or any custom object.

Common situations: Passing a state_dict directly instead of a list of tensors; passing a generator expecting lazy iteration; passing a single tensor per module.

Related errors

• Module(s) requested for update not found in pipeline: {unkno
• Missing tensor payload for module(s): {missing}. Provided mo
• flattened_bucket payload must be a dict with 'flattened_tens
• Z-Image text embeddings must have shape [seq, dim] or [batch
• f"Unsupported patch_size type: {type(patch_size)}"

AI-assisted analysis of sgl-project/sglang@0132848349 (2026-08-28). Data as JSON: /api/errors/f31c28a13adcabda. Report an issue: GitHub.