diff --git a/python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/test/passthrough.py b/python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/test/passthrough.py new file mode 100644 index 0000000000..fd74da85e4 --- /dev/null +++ b/python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/test/passthrough.py @@ -0,0 +1,44 @@ +"""Shared request setup and output checks for direct ComfyUI pipeline tests.""" + +import torch + + +def prepare_passthrough_request(req): + if req.guidance_scale > 1.0 and req.negative_prompt_embeds is not None: + req.do_classifier_free_guidance = True + else: + req.do_classifier_free_guidance = False + if req.seed is not None: + generator_device = req.generator_device + device_str = "cpu" if generator_device == "cpu" else "cuda" + req.generator = [ + torch.Generator(device_str).manual_seed(req.seed + i) + for i in range(req.num_outputs_per_prompt) + ] + else: + req.generator = [ + torch.Generator("cuda") for _ in range(req.num_outputs_per_prompt) + ] + + +def check_passthrough_output(generator, req, *, label=""): + output_batch = generator._send_to_scheduler_and_wait_for_response([req]) + noise_pred = output_batch.noise_pred + + assert noise_pred is not None, "noise_pred should not be None in OutputBatch" + assert isinstance(noise_pred, torch.Tensor), "noise_pred should be a torch.Tensor" + assert noise_pred.device.type == "cuda", ( + f"noise_pred should be on cuda, got {noise_pred.device}" + ) + assert noise_pred.dtype == torch.bfloat16, ( + f"noise_pred should be bfloat16, got {noise_pred.dtype}" + ) + + print(f"\u2713 Successfully retrieved noise_pred from OutputBatch{label}!") + print(f" noise_pred shape: {noise_pred.shape}") + print(f" noise_pred dtype: {noise_pred.dtype}") + print(f" noise_pred device: {noise_pred.device}") + + latents = output_batch.output if output_batch.output is not None else req.latents + assert latents is not None, "latents should not be None" + return latents diff --git a/python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/test/test_flux_pipeline.py b/python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/test/test_flux_pipeline.py index 7c3c02e361..0b5f72040d 100644 --- a/python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/test/test_flux_pipeline.py +++ b/python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/test/test_flux_pipeline.py @@ -6,6 +6,9 @@ import sys import pytest import torch +from sglang.multimodal_gen.apps.ComfyUI_SGLDiffusion.test.passthrough import ( + check_passthrough_output, +) from sglang.multimodal_gen.configs.sample.sampling_params import SamplingParams from sglang.multimodal_gen.runtime.entrypoints.diffusion_generator import DiffGenerator from sglang.multimodal_gen.runtime.entrypoints.utils import prepare_request @@ -140,25 +143,7 @@ def test_comfyui_flux_pipeline_direct() -> None: torch.Generator("cuda") for _ in range(req.num_outputs_per_prompt) ] - output_batch = generator._send_to_scheduler_and_wait_for_response([req]) - noise_pred = output_batch.noise_pred - - assert noise_pred is not None, "noise_pred should not be None in OutputBatch" - assert isinstance(noise_pred, torch.Tensor), "noise_pred should be a torch.Tensor" - assert noise_pred.device.type == "cuda", ( - f"noise_pred should be on cuda, got {noise_pred.device}" - ) - assert noise_pred.dtype == torch.bfloat16, ( - f"noise_pred should be bfloat16, got {noise_pred.dtype}" - ) - - print("✓ Successfully retrieved noise_pred from OutputBatch!") - print(f" noise_pred shape: {noise_pred.shape}") - print(f" noise_pred dtype: {noise_pred.dtype}") - print(f" noise_pred device: {noise_pred.device}") - - latents = output_batch.output if output_batch.output is not None else req.latents - assert latents is not None, "latents should not be None" + latents = check_passthrough_output(generator, req) print(f"latents.shape: {latents.shape}") diff --git a/python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/test/test_qwen_image_edit_pipeline.py b/python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/test/test_qwen_image_edit_pipeline.py index 017f3c3fab..3c147c0bdc 100644 --- a/python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/test/test_qwen_image_edit_pipeline.py +++ b/python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/test/test_qwen_image_edit_pipeline.py @@ -6,6 +6,10 @@ import sys import pytest import torch +from sglang.multimodal_gen.apps.ComfyUI_SGLDiffusion.test.passthrough import ( + check_passthrough_output, + prepare_passthrough_request, +) from sglang.multimodal_gen.configs.sample.sampling_params import SamplingParams from sglang.multimodal_gen.runtime.entrypoints.diffusion_generator import DiffGenerator from sglang.multimodal_gen.runtime.entrypoints.utils import prepare_request @@ -94,42 +98,9 @@ def test_comfyui_qwen_image_edit_pipeline_direct() -> None: req.vae_image_sizes = [(condition_width_latent, condition_height_latent)] req.raw_latent_shape = torch.tensor(noisy_image_latents.shape, dtype=torch.long) - if req.guidance_scale > 1.0 and req.negative_prompt_embeds is not None: - req.do_classifier_free_guidance = True - else: - req.do_classifier_free_guidance = False + prepare_passthrough_request(req) - if req.seed is not None: - generator_device = req.generator_device - device_str = "cpu" if generator_device == "cpu" else "cuda" - req.generator = [ - torch.Generator(device_str).manual_seed(req.seed + i) - for i in range(req.num_outputs_per_prompt) - ] - else: - req.generator = [ - torch.Generator("cuda") for _ in range(req.num_outputs_per_prompt) - ] - - output_batch = generator._send_to_scheduler_and_wait_for_response([req]) - noise_pred = output_batch.noise_pred - - assert noise_pred is not None, "noise_pred should not be None in OutputBatch" - assert isinstance(noise_pred, torch.Tensor), "noise_pred should be a torch.Tensor" - assert noise_pred.device.type == "cuda", ( - f"noise_pred should be on cuda, got {noise_pred.device}" - ) - assert noise_pred.dtype == torch.bfloat16, ( - f"noise_pred should be bfloat16, got {noise_pred.dtype}" - ) - - print("✓ Successfully retrieved noise_pred from OutputBatch (Edit Mode)!") - print(f" noise_pred shape: {noise_pred.shape}") - print(f" noise_pred dtype: {noise_pred.dtype}") - print(f" noise_pred device: {noise_pred.device}") - - latents = output_batch.output if output_batch.output is not None else req.latents - assert latents is not None, "latents should not be None" + check_passthrough_output(generator, req, label=" (Edit Mode)") if __name__ == "__main__": diff --git a/python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/test/test_qwen_image_pipeline.py b/python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/test/test_qwen_image_pipeline.py index 671d731472..395ccf8323 100644 --- a/python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/test/test_qwen_image_pipeline.py +++ b/python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/test/test_qwen_image_pipeline.py @@ -6,6 +6,10 @@ import sys import pytest import torch +from sglang.multimodal_gen.apps.ComfyUI_SGLDiffusion.test.passthrough import ( + check_passthrough_output, + prepare_passthrough_request, +) from sglang.multimodal_gen.configs.sample.sampling_params import SamplingParams from sglang.multimodal_gen.runtime.entrypoints.diffusion_generator import DiffGenerator from sglang.multimodal_gen.runtime.entrypoints.utils import prepare_request @@ -78,42 +82,9 @@ def test_comfyui_qwen_image_pipeline_direct() -> None: req.negative_prompt_embeds = [encoder_hidden_states] req.raw_latent_shape = torch.tensor(hidden_states.shape, dtype=torch.long) - if req.guidance_scale > 1.0 and req.negative_prompt_embeds is not None: - req.do_classifier_free_guidance = True - else: - req.do_classifier_free_guidance = False + prepare_passthrough_request(req) - if req.seed is not None: - generator_device = req.generator_device - device_str = "cpu" if generator_device == "cpu" else "cuda" - req.generator = [ - torch.Generator(device_str).manual_seed(req.seed + i) - for i in range(req.num_outputs_per_prompt) - ] - else: - req.generator = [ - torch.Generator("cuda") for _ in range(req.num_outputs_per_prompt) - ] - - output_batch = generator._send_to_scheduler_and_wait_for_response([req]) - noise_pred = output_batch.noise_pred - - assert noise_pred is not None, "noise_pred should not be None in OutputBatch" - assert isinstance(noise_pred, torch.Tensor), "noise_pred should be a torch.Tensor" - assert noise_pred.device.type == "cuda", ( - f"noise_pred should be on cuda, got {noise_pred.device}" - ) - assert noise_pred.dtype == torch.bfloat16, ( - f"noise_pred should be bfloat16, got {noise_pred.dtype}" - ) - - print("✓ Successfully retrieved noise_pred from OutputBatch!") - print(f" noise_pred shape: {noise_pred.shape}") - print(f" noise_pred dtype: {noise_pred.dtype}") - print(f" noise_pred device: {noise_pred.device}") - - latents = output_batch.output if output_batch.output is not None else req.latents - assert latents is not None, "latents should not be None" + check_passthrough_output(generator, req) if __name__ == "__main__": diff --git a/python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/test/test_zimage_pipeline.py b/python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/test/test_zimage_pipeline.py index 93f1112e32..c36308d697 100644 --- a/python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/test/test_zimage_pipeline.py +++ b/python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/test/test_zimage_pipeline.py @@ -6,6 +6,10 @@ import sys import pytest import torch +from sglang.multimodal_gen.apps.ComfyUI_SGLDiffusion.test.passthrough import ( + check_passthrough_output, + prepare_passthrough_request, +) from sglang.multimodal_gen.configs.sample.sampling_params import SamplingParams from sglang.multimodal_gen.runtime.entrypoints.diffusion_generator import DiffGenerator from sglang.multimodal_gen.runtime.entrypoints.utils import prepare_request @@ -81,42 +85,9 @@ def test_comfyui_zimage_pipeline_direct() -> None: req.negative_prompt_embeds = None req.raw_latent_shape = torch.tensor(latents.shape, dtype=torch.long) - if req.guidance_scale > 1.0 and req.negative_prompt_embeds is not None: - req.do_classifier_free_guidance = True - else: - req.do_classifier_free_guidance = False + prepare_passthrough_request(req) - if req.seed is not None: - generator_device = req.generator_device - device_str = "cpu" if generator_device == "cpu" else "cuda" - req.generator = [ - torch.Generator(device_str).manual_seed(req.seed + i) - for i in range(req.num_outputs_per_prompt) - ] - else: - req.generator = [ - torch.Generator("cuda") for _ in range(req.num_outputs_per_prompt) - ] - - output_batch = generator._send_to_scheduler_and_wait_for_response([req]) - noise_pred = output_batch.noise_pred - - assert noise_pred is not None, "noise_pred should not be None in OutputBatch" - assert isinstance(noise_pred, torch.Tensor), "noise_pred should be a torch.Tensor" - assert noise_pred.device.type == "cuda", ( - f"noise_pred should be on cuda, got {noise_pred.device}" - ) - assert noise_pred.dtype == torch.bfloat16, ( - f"noise_pred should be bfloat16, got {noise_pred.dtype}" - ) - - print("✓ Successfully retrieved noise_pred from OutputBatch!") - print(f" noise_pred shape: {noise_pred.shape}") - print(f" noise_pred dtype: {noise_pred.dtype}") - print(f" noise_pred device: {noise_pred.device}") - - latents = output_batch.output if output_batch.output is not None else req.latents - assert latents is not None, "latents should not be None" + check_passthrough_output(generator, req) if __name__ == "__main__": diff --git a/python/sglang/multimodal_gen/runtime/entrypoints/openai/image_api.py b/python/sglang/multimodal_gen/runtime/entrypoints/openai/image_api.py index 18f856cc49..25f4211e9b 100644 --- a/python/sglang/multimodal_gen/runtime/entrypoints/openai/image_api.py +++ b/python/sglang/multimodal_gen/runtime/entrypoints/openai/image_api.py @@ -5,7 +5,7 @@ import base64 import contextlib import os import time -from typing import Any, List, Optional +from typing import List, Optional from fastapi import ( APIRouter, @@ -40,10 +40,11 @@ from sglang.multimodal_gen.runtime.entrypoints.openai.utils import ( add_common_data_to_response, build_sampling_params, choose_output_image_ext, - get_sampling_request_extra_fields, merge_image_input_list, process_generation_batch, request_extra_value, + request_field_value, + request_model_kwargs, resolve_sampling_params_cls, sanitize_upload_filename, save_image_to_path, @@ -58,31 +59,6 @@ from sglang.srt.observability.trace import extract_trace_headers router = APIRouter(prefix="/v1/images", tags=["images"]) -def _get_extra_field(request, field_name): - return request_extra_value(request, field_name) - - -def _get_request_field_or_extra(request, field_name): - value = getattr(request, field_name, None) - if value is not None: - return value - return _get_extra_field(request, field_name) - - -def _image_request_model_kwargs( - request: ImageGenerationsRequest, - sampling_params_cls: type[SamplingParams], -) -> dict[str, Any]: - """Extract fields owned and declared by the active model contract.""" - - kwargs = {} - for field_name in get_sampling_request_extra_fields(sampling_params_cls, "image"): - value = _get_extra_field(request, field_name) - if value is not None: - kwargs[field_name] = value - return kwargs - - def _runtime_sampling_quality(quality: str | None) -> str | None: """Keep OpenAI's automatic default out of SGLang's sampling contract.""" return None if quality in (None, "auto") else quality @@ -280,7 +256,7 @@ async def generations( request_id = generate_request_id() server_args = get_global_server_args() sampling_params_cls = resolve_sampling_params_cls(server_args) - model_kwargs = _image_request_model_kwargs(request, sampling_params_cls) + model_kwargs = request_model_kwargs(request, sampling_params_cls, "image") output_format = _resolve_image_output_format( request.output_format, sampling_params_cls ) @@ -308,24 +284,16 @@ async def generations( guidance_scale=request.guidance_scale, true_cfg_scale=request.true_cfg_scale, negative_prompt=request.negative_prompt, - max_sequence_length=( - request.max_sequence_length - if request.max_sequence_length is not None - else _get_extra_field(request, "max_sequence_length") - ), - flow_shift=( - request.flow_shift - if request.flow_shift is not None - else _get_extra_field(request, "flow_shift") - ), + max_sequence_length=request_field_value(request, "max_sequence_length"), + flow_shift=request_field_value(request, "flow_shift"), enable_teacache=request.enable_teacache, - enable_cache_dit=_get_extra_field(request, "enable_cache_dit"), - cache_dit_params=_get_extra_field(request, "cache_dit_params"), - cfg_gate_step=_get_extra_field(request, "cfg_gate_step"), - attention_backend_override=_get_extra_field( + enable_cache_dit=request_extra_value(request, "enable_cache_dit"), + cache_dit_params=request_extra_value(request, "cache_dit_params"), + cfg_gate_step=request_extra_value(request, "cfg_gate_step"), + attention_backend_override=request_extra_value( request, "attention_backend_override" ), - skip_softmax_params=_get_extra_field(request, "skip_softmax_params"), + skip_softmax_params=request_extra_value(request, "skip_softmax_params"), quality=_runtime_sampling_quality(request.quality), output_compression=request.output_compression, output_quality=request.output_quality, @@ -334,11 +302,9 @@ async def generations( upscaling_model_path=request.upscaling_model_path, upscaling_scale=request.upscaling_scale, perf_dump_path=request.perf_dump_path, - progressive_mode=_get_request_field_or_extra(request, "progressive_mode"), - progressive_levels=_get_request_field_or_extra( - request, "progressive_levels" - ), - progressive_delta=_get_request_field_or_extra(request, "progressive_delta"), + progressive_mode=request_field_value(request, "progressive_mode"), + progressive_levels=request_field_value(request, "progressive_levels"), + progressive_delta=request_field_value(request, "progressive_delta"), **model_kwargs, ) trace_headers = extract_trace_headers(raw_request.headers) diff --git a/python/sglang/multimodal_gen/runtime/entrypoints/openai/utils.py b/python/sglang/multimodal_gen/runtime/entrypoints/openai/utils.py index e036a4ab3e..e10515b903 100644 --- a/python/sglang/multimodal_gen/runtime/entrypoints/openai/utils.py +++ b/python/sglang/multimodal_gen/runtime/entrypoints/openai/utils.py @@ -14,6 +14,7 @@ from typing import Any, Generator, List, Literal, Optional, Union import httpx from fastapi import HTTPException, UploadFile +from pydantic import BaseModel from sglang.multimodal_gen.configs.sample.sampling_params import ( DataType, @@ -147,6 +148,14 @@ def request_extra_value(request: Any, field_name: str) -> Any: return None +def request_field_value(request: BaseModel, field_name: str) -> Any: + """Prefer a non-None protocol field over transport extras.""" + value = vars(request).get(field_name) + if value is not None: + return value + return request_extra_value(request, field_name) + + @cache def get_declared_request_extra_fields( sampling_params_cls: type[SamplingParams], @@ -178,6 +187,20 @@ def get_sampling_request_extra_fields( return declared & init_fields +def request_model_kwargs( + request: BaseModel, + sampling_params_cls: type[SamplingParams], + api: Literal["image", "video"], +) -> dict[str, Any]: + """Extract only constructor fields declared by the active model contract.""" + kwargs = {} + for field_name in get_sampling_request_extra_fields(sampling_params_cls, api): + value = request_extra_value(request, field_name) + if value is not None: + kwargs[field_name] = value + return kwargs + + @contextmanager def temp_dir_if_disabled( configured_path: str | None, diff --git a/python/sglang/multimodal_gen/runtime/entrypoints/openai/video_api.py b/python/sglang/multimodal_gen/runtime/entrypoints/openai/video_api.py index 0b33ff1b64..c5adf7de25 100644 --- a/python/sglang/multimodal_gen/runtime/entrypoints/openai/video_api.py +++ b/python/sglang/multimodal_gen/runtime/entrypoints/openai/video_api.py @@ -44,10 +44,11 @@ from sglang.multimodal_gen.runtime.entrypoints.openai.utils import ( build_sampling_params, flatten_extra_params, get_declared_request_extra_fields, - get_sampling_request_extra_fields, merge_image_input_list, process_generation_batch, request_extra_value, + request_field_value, + request_model_kwargs, resolve_sampling_params_cls, sanitize_upload_filename, save_image_to_path, @@ -97,31 +98,6 @@ async def shutdown_video_jobs() -> None: await task -def _extra_value(request: VideoGenerationsRequest, name: str) -> Any: - return request_extra_value(request, name) - - -def _request_value(request: VideoGenerationsRequest, name: str) -> Any: - value = getattr(request, name, None) - if value is not None: - return value - return _extra_value(request, name) - - -def _video_request_model_kwargs( - request: VideoGenerationsRequest, - sampling_params_cls: type[SamplingParams], -) -> dict[str, Any]: - """Extract fields owned and declared by the active model contract.""" - - kwargs = {} - for field_name in get_sampling_request_extra_fields(sampling_params_cls, "video"): - value = _extra_value(request, field_name) - if value is not None: - kwargs[field_name] = value - return kwargs - - def _parse_form_extra_value(value: Any) -> Any: if not isinstance(value, str): return value @@ -229,15 +205,17 @@ def _is_probably_video_source(source: Any) -> bool: def _resolve_video_path(req: VideoGenerationsRequest) -> str | None: - video_path = _request_value(req, "video_path") or _request_value(req, "video_url") + video_path = request_field_value(req, "video_path") or request_field_value( + req, "video_url" + ) if video_path: return str(video_path) - input_reference = _request_value(req, "input_reference") + input_reference = request_field_value(req, "input_reference") if _is_probably_video_source(input_reference): return str(input_reference) - reference_url = _request_value(req, "reference_url") + reference_url = request_field_value(req, "reference_url") if _is_probably_video_source(reference_url): return str(reference_url) @@ -247,7 +225,7 @@ def _resolve_video_path(req: VideoGenerationsRequest) -> str | None: def _resolve_image_path( req: VideoGenerationsRequest, video_path: str | None ) -> str | None: - image_path = _request_value(req, "input_reference") + image_path = request_field_value(req, "input_reference") if video_path and image_path == video_path: return None if _is_probably_video_source(image_path): @@ -292,14 +270,14 @@ def _build_video_sampling_params(request_id: str, request: VideoGenerationsReque "max_sequence_length": request.max_sequence_length, "flow_shift": request.flow_shift, "enable_teacache": request.enable_teacache, - "use_diffusion_decoder": _extra_value(request, "use_diffusion_decoder"), - "enable_cache_dit": _extra_value(request, "enable_cache_dit"), - "cache_dit_params": _extra_value(request, "cache_dit_params"), - "cfg_gate_step": _extra_value(request, "cfg_gate_step"), - "attention_backend_override": _extra_value( + "use_diffusion_decoder": request_extra_value(request, "use_diffusion_decoder"), + "enable_cache_dit": request_extra_value(request, "enable_cache_dit"), + "cache_dit_params": request_extra_value(request, "cache_dit_params"), + "cfg_gate_step": request_extra_value(request, "cfg_gate_step"), + "attention_backend_override": request_extra_value( request, "attention_backend_override" ), - "skip_softmax_params": _extra_value(request, "skip_softmax_params"), + "skip_softmax_params": request_extra_value(request, "skip_softmax_params"), "enable_frame_interpolation": request.enable_frame_interpolation, "frame_interpolation_exp": request.frame_interpolation_exp, "frame_interpolation_scale": request.frame_interpolation_scale, @@ -308,7 +286,7 @@ def _build_video_sampling_params(request_id: str, request: VideoGenerationsReque "upscaling_model_path": request.upscaling_model_path, "upscaling_scale": request.upscaling_scale, "output_path": request.output_path, - "quality": _extra_value(request, "quality"), + "quality": request_extra_value(request, "quality"), "output_compression": request.output_compression, "x264_preset": request.x264_preset, "output_quality": request.output_quality, @@ -317,7 +295,7 @@ def _build_video_sampling_params(request_id: str, request: VideoGenerationsReque "num_profiled_timesteps": request.num_profiled_timesteps, "profile_all_stages": request.profile_all_stages, "diffusers_kwargs": request.diffusers_kwargs, - **_video_request_model_kwargs(request, sampling_params_cls), + **request_model_kwargs(request, sampling_params_cls, "video"), } kwargs = sampling_params_cls.lower_video_request_kwargs(request, kwargs) diff --git a/python/sglang/multimodal_gen/runtime/models/decoders/ltx_2_5_diffusion_decoder.py b/python/sglang/multimodal_gen/runtime/models/decoders/ltx_2_5_diffusion_decoder.py index 90b6dd2e00..443d35c8bf 100644 --- a/python/sglang/multimodal_gen/runtime/models/decoders/ltx_2_5_diffusion_decoder.py +++ b/python/sglang/multimodal_gen/runtime/models/decoders/ltx_2_5_diffusion_decoder.py @@ -680,6 +680,8 @@ class LTX2VideoDiffusionDecoder3d(nn.Module): self.trailing_pad_latent_frames = (stage_kernels[0][0] // 2) * 2 self.conv_in = nn.Linear(arch.latent_channels, stage_channels[0], bias=True) + # checkpoint keyframe-stream tag; ordinary video decoding does not use it + self.type_emb = nn.Parameter(torch.zeros(arch.latent_channels)) self.det_stages = nn.ModuleList() self.upsamples = nn.ModuleList() @@ -730,6 +732,31 @@ class LTX2VideoDiffusionDecoder3d(nn.Module): self.norm_out = nn.RMSNorm(stage5_channels, eps=1e-6) self.conv_out = nn.Linear(stage5_channels, noised_pixel_channels, bias=True) + def _load_from_state_dict( + self, + state_dict, + prefix, + local_metadata, + strict, + missing_keys, + unexpected_keys, + error_msgs, + ): + # older checkpoints predate the keyframe tag and use a zero embedding + state_dict.setdefault( + prefix + "type_emb", + torch.zeros(self.type_emb.shape, dtype=self.type_emb.dtype, device="cpu"), + ) + super()._load_from_state_dict( + state_dict, + prefix, + local_metadata, + strict, + missing_keys, + unexpected_keys, + error_msgs, + ) + def forward_stages_1_to_3(self, hidden_states: torch.Tensor) -> torch.Tensor: """Latent `(B, C, T, H, W)` to a channels-last feature volume.""" num_pad = self.trailing_pad_latent_frames diff --git a/python/sglang/multimodal_gen/test/unit/test_cosmos3.py b/python/sglang/multimodal_gen/test/unit/test_cosmos3.py index 993bf3a38c..8b1bc7c56a 100644 --- a/python/sglang/multimodal_gen/test/unit/test_cosmos3.py +++ b/python/sglang/multimodal_gen/test/unit/test_cosmos3.py @@ -41,10 +41,10 @@ from sglang.multimodal_gen.runtime.entrypoints.openai.protocol import ( ImageGenerationsRequest, VideoGenerationsRequest, ) +from sglang.multimodal_gen.runtime.entrypoints.openai.utils import request_model_kwargs from sglang.multimodal_gen.runtime.entrypoints.openai.video_api import ( _multipart_video_extras, _resolve_video_path, - _video_request_model_kwargs, ) from sglang.multimodal_gen.runtime.loader.component_loaders import scheduler_loader from sglang.multimodal_gen.runtime.loader.component_loaders.scheduler_loader import ( @@ -1059,7 +1059,7 @@ class TestCosmos3OpenAIProtocol(unittest.TestCase): self.assertEqual(_resolve_video_path(req), "https://example.com/input.mp4") - kwargs = _video_request_model_kwargs(req, Cosmos3SamplingParams) + kwargs = request_model_kwargs(req, Cosmos3SamplingParams, "video") kwargs.update(num_frames=48, fps=24) kwargs = Cosmos3SamplingParams.lower_video_request_kwargs(req, kwargs) self.assertEqual(kwargs["sound_duration"], 2.0) @@ -1117,7 +1117,7 @@ class TestCosmos3OpenAIProtocol(unittest.TestCase): req = VideoGenerationsRequest( prompt="test", generate_sound=False, sound_duration=3.0 ) - kwargs = _video_request_model_kwargs(req, Cosmos3SamplingParams) + kwargs = request_model_kwargs(req, Cosmos3SamplingParams, "video") kwargs.update(num_frames=48, fps=24) kwargs = Cosmos3SamplingParams.lower_video_request_kwargs(req, kwargs) self.assertEqual(kwargs["sound_duration"], 0.0) diff --git a/python/sglang/multimodal_gen/test/unit/test_openai_image_api.py b/python/sglang/multimodal_gen/test/unit/test_openai_image_api.py index 1f6c40ecb9..865bc11602 100644 --- a/python/sglang/multimodal_gen/test/unit/test_openai_image_api.py +++ b/python/sglang/multimodal_gen/test/unit/test_openai_image_api.py @@ -19,7 +19,6 @@ from sglang.multimodal_gen.runtime.entrypoints.openai.image_api import ( _build_image_response_kwargs, _fallback_image_urls, _get_response_resize, - _image_request_model_kwargs, _raise_if_image_variant_not_found, _runtime_sampling_quality, _select_image_variant_cloud_url, @@ -29,6 +28,7 @@ from sglang.multimodal_gen.runtime.entrypoints.openai.image_api import ( from sglang.multimodal_gen.runtime.entrypoints.openai.protocol import ( ImageGenerationsRequest, ) +from sglang.multimodal_gen.runtime.entrypoints.openai.utils import request_model_kwargs from sglang.multimodal_gen.runtime.pipelines_core.schedule_batch import OutputBatch @@ -84,10 +84,10 @@ def test_longcat_image_fields_remain_model_specific(): assert field_name in longcat_fields assert getattr(request, field_name) == value - assert _image_request_model_kwargs(request, LongCatImageSamplingParams) == ( + assert request_model_kwargs(request, LongCatImageSamplingParams, "image") == ( field_values ) - assert _image_request_model_kwargs(request, SamplingParams) == {} + assert request_model_kwargs(request, SamplingParams, "image") == {} def test_longcat_image_fields_accept_nested_extra_body(): @@ -101,7 +101,7 @@ def test_longcat_image_fields_accept_nested_extra_body(): }, ) - assert _image_request_model_kwargs(request, LongCatImageSamplingParams) == { + assert request_model_kwargs(request, LongCatImageSamplingParams, "image") == { "enable_prompt_rewrite": True, "enable_cfg_renorm": False, "cfg_renorm_min": 0.5, @@ -127,10 +127,10 @@ def test_other_image_extensions_remain_model_specific(): assert field_name not in ImageGenerationsRequest.model_fields assert field_name not in base_fields assert field_name in model_fields - assert _image_request_model_kwargs(request, sampling_params_cls) == { + assert request_model_kwargs(request, sampling_params_cls, "image") == { field_name: value } - assert _image_request_model_kwargs(request, SamplingParams) == {} + assert request_model_kwargs(request, SamplingParams, "image") == {} def test_cosmos_image_guardrails_alias_is_preserved(): @@ -139,7 +139,7 @@ def test_cosmos_image_guardrails_alias_is_preserved(): extra_body={"guardrails": False}, ) - assert _image_request_model_kwargs(request, Cosmos3SamplingParams) == { + assert request_model_kwargs(request, Cosmos3SamplingParams, "image") == { "use_guardrails": False } diff --git a/python/sglang/multimodal_gen/test/unit/test_openai_utils.py b/python/sglang/multimodal_gen/test/unit/test_openai_utils.py index 91a5075356..25cecc9ad9 100644 --- a/python/sglang/multimodal_gen/test/unit/test_openai_utils.py +++ b/python/sglang/multimodal_gen/test/unit/test_openai_utils.py @@ -2,20 +2,57 @@ import asyncio import io +import json from types import SimpleNamespace from starlette.datastructures import UploadFile as StarletteUploadFile +from sglang.multimodal_gen.configs.sample.minimax_h3 import MiniMaxH3SamplingParams from sglang.multimodal_gen.configs.sample.sampling_params import SamplingParams from sglang.multimodal_gen.runtime.entrypoints.openai import utils as openai_utils +from sglang.multimodal_gen.runtime.entrypoints.openai.protocol import ( + ImageGenerationsRequest, + VideoGenerationsRequest, +) from sglang.multimodal_gen.runtime.entrypoints.openai.utils import ( _parse_size_or_raise, _save_upload_to_path, _validate_positive_int, build_sampling_params, + request_field_value, + request_model_kwargs, ) +def test_request_fields_preserve_falsy_values_and_extra_precedence(): + for cls in (ImageGenerationsRequest, VideoGenerationsRequest): + for container in ("extra_body", "extra_json", "extra_args", "extra_params"): + for direct in (0, None): + request = cls( + prompt="test", + seed=direct, + enable_cache_dit=False, + **{container: json.dumps({"seed": 42, "enable_cache_dit": True})}, + ) + before = request.model_dump() + assert request_field_value(request, "seed") == ( + 42 if direct is None else 0 + ) + assert request_field_value(request, "enable_cache_dit") is False + assert request.model_dump() == before + + +def test_video_model_kwargs_exclude_transport_only_aliases(): + request = VideoGenerationsRequest( + prompt="test", extra_body={"task": "t2va", "audio_guidance_scale": 2.0} + ) + assert request_model_kwargs(request, MiniMaxH3SamplingParams, "video") == { + "task": "t2va" + } + assert request.model_extra["extra_body"]["audio_guidance_scale"] == 2.0 + assert request_model_kwargs(request, MiniMaxH3SamplingParams, "image") == {} + + def test_save_upload_to_path_accepts_starlette_upload_file(tmp_path): upload = StarletteUploadFile( io.BytesIO(b"image-bytes"), diff --git a/python/sglang/multimodal_gen/test/unit/test_plain_state_dict_loaders.py b/python/sglang/multimodal_gen/test/unit/test_plain_state_dict_loaders.py index ae02219a3d..5f52e85ecf 100644 --- a/python/sglang/multimodal_gen/test/unit/test_plain_state_dict_loaders.py +++ b/python/sglang/multimodal_gen/test/unit/test_plain_state_dict_loaders.py @@ -193,6 +193,43 @@ def test_real_components_restore_weights_and_exact_policy( torch.testing.assert_close(model(inputs), reference(inputs), rtol=0, atol=0) +@pytest.mark.parametrize("has_type_embedding", [False, True]) +def test_diffusion_decoder_restores_optional_keyframe_tag(tmp_path, has_type_embedding): + role, class_name, config_cls, raw_config = CASES[3] + config = config_cls() + config.update_model_arch(raw_config) + model_cls, _ = ModelRegistry.resolve_model_cls(class_name) + reference = model_cls(config) + with torch.no_grad(): + for parameter in reference.parameters(): + parameter.fill_(0.25) + weights = reference.state_dict() + if not has_type_embedding: + weights.pop("decoder.type_emb") + component = tmp_path / role + _write_checkpoint(component, {"_class_name": class_name, **raw_config}, weights) + args = ServerArgs( + model_path="x", + component_precisions={role: "fp32"}, + component_residency={role: "component-offload"}, + ) + model, _ = PipelineComponentLoader.load_component( + role, str(component), "diffusers", args + ) + expected = torch.full( + (raw_config["latent_channels"],), 0.25 if has_type_embedding else 0.0 + ) + torch.testing.assert_close(model.decoder.type_emb.cpu(), expected, rtol=0, atol=0) + for key, tensor in weights.items(): + torch.testing.assert_close( + model.state_dict()[key].cpu(), tensor, rtol=0, atol=0 + ) + with pytest.raises(RuntimeError, match="size mismatch for decoder.type_emb"): + model.load_state_dict({**weights, "decoder.type_emb": torch.zeros(5)}) + with pytest.raises(RuntimeError, match="Unexpected key"): + model.load_state_dict({**weights, "decoder.unknown": torch.zeros(1)}) + + class _DecoderOnly(nn.Module): def __init__(self, config): super().__init__() diff --git a/python/sglang/multimodal_gen/test/unit/test_video_api_profiling.py b/python/sglang/multimodal_gen/test/unit/test_video_api_profiling.py index a44542466c..5bc588c289 100644 --- a/python/sglang/multimodal_gen/test/unit/test_video_api_profiling.py +++ b/python/sglang/multimodal_gen/test/unit/test_video_api_profiling.py @@ -14,9 +14,9 @@ from sglang.multimodal_gen.runtime.entrypoints.openai.realtime.realtime_adapter RealtimeChunkInputs, build_realtime_sampling_params, ) +from sglang.multimodal_gen.runtime.entrypoints.openai.utils import request_model_kwargs from sglang.multimodal_gen.runtime.entrypoints.openai.video_api import ( _build_video_sampling_params, - _video_request_model_kwargs, create_video, ) from sglang.multimodal_gen.runtime.pipelines_core.schedule_batch import Req @@ -88,8 +88,8 @@ def test_ltx25_video_extensions_remain_model_specific(): assert field_name not in base_fields assert field_name in ltx25_fields - assert _video_request_model_kwargs(request, LTX25SamplingParams) == field_values - assert _video_request_model_kwargs(request, SamplingParams) == {} + assert request_model_kwargs(request, LTX25SamplingParams, "video") == field_values + assert request_model_kwargs(request, SamplingParams, "video") == {} def test_ltx23_request_defaults_to_vae_decoder():