[Feature] Support standard OpenAI API sampling parameters for thinker stage. (max_tokens...) (#450)

Signed-off-by: wonjae.lee0 <wonjae.lee0@navercorp.com>
Co-authored-by: wonjae.lee0 <wonjae.lee0@navercorp.com>
This commit is contained in:
Wonjae Leeandwonjae.lee0 authored and GitHub committed 2025-12-24 20:39:01 +08:00
1 parent da7f25e14b
commit 341457a121
6 files changed
+416 -4

No files matched your search

Whitespace-only changes.
@@ -0,0 +1,439 @@
# SPDX-License-Identifier: Apache-2.0
# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
"""
Tests for async image generation API endpoints.
This module contains unit tests and integration tests (with mocking) for the
OpenAI-compatible async text-to-image generation API endpoints in api_server.py.
"""
import base64
import io
from unittest.mock import AsyncMock, Mock
import pytest
from fastapi.testclient import TestClient
from PIL import Image
from vllm_omni.entrypoints.openai.image_api_utils import (
encode_image_base64,
parse_size,
)
# Unit Tests
def test_parse_size_valid():
"""Test size parsing with valid inputs"""
assert parse_size("1024x1024") == (1024, 1024)
assert parse_size("512x768") == (512, 768)
assert parse_size("256x256") == (256, 256)
assert parse_size("1792x1024") == (1792, 1024)
assert parse_size("1024x1792") == (1024, 1792)
def test_parse_size_invalid():
"""Test size parsing with invalid inputs"""
with pytest.raises(ValueError, match="Invalid size format"):
parse_size("invalid")
with pytest.raises(ValueError, match="Invalid size format"):
parse_size("1024")
with pytest.raises(ValueError, match="Invalid size format"):
parse_size("1024x")
with pytest.raises(ValueError, match="Invalid size format"):
parse_size("x1024")
def test_parse_size_negative():
"""Test size parsing with negative or zero dimensions"""
with pytest.raises(ValueError, match="positive integers"):
parse_size("0x1024")
with pytest.raises(ValueError, match="positive integers"):
parse_size("1024x0")
with pytest.raises(ValueError):
parse_size("-1024x1024")
def test_parse_size_edge_cases():
"""Test size parsing with edge cases like empty strings and non-integers"""
# Empty string
with pytest.raises(ValueError, match="non-empty string"):
parse_size("")
# Non-integer dimensions
with pytest.raises(ValueError, match="must be integers"):
parse_size("abc x def")
with pytest.raises(ValueError, match="must be integers"):
parse_size("1024.5x768.5")
# Missing separator (user might forget 'x')
with pytest.raises(ValueError, match="separator"):
parse_size("1024 1024")
def test_encode_image_base64():
"""Test image encoding to base64"""
# Create a simple test image
img = Image.new("RGB", (64, 64), color="red")
b64_str = encode_image_base64(img)
# Should be valid base64
assert isinstance(b64_str, str)
assert len(b64_str) > 0
# Should decode back to PNG
decoded = base64.b64decode(b64_str)
decoded_img = Image.open(io.BytesIO(decoded))
# Verify properties
assert decoded_img.size == (64, 64)
assert decoded_img.format == "PNG"
# Integration Tests (with mocking)
class MockGenerationResult:
"""Mock result object from AsyncOmniDiffusion.generate()"""
def __init__(self, images):
self.images = images
@pytest.fixture
def mock_async_diffusion():
"""Mock AsyncOmniDiffusion instance that returns fake images"""
mock = Mock()
async def generate(**kwargs):
# Return n PIL images wrapped in result object
n = kwargs.get("num_outputs_per_prompt", 1)
images = [Image.new("RGB", (64, 64), color="blue") for _ in range(n)]
return MockGenerationResult(images)
mock.generate = AsyncMock(side_effect=generate)
return mock
@pytest.fixture
def test_client(mock_async_diffusion):
"""Create test client with mocked async diffusion engine"""
from fastapi import FastAPI
from vllm_omni.entrypoints.openai.api_server import router
app = FastAPI()
app.include_router(router)
# Set up app state with diffusion engine
app.state.diffusion_engine = mock_async_diffusion
app.state.diffusion_model_name = "Qwen/Qwen-Image"
return TestClient(app)
@pytest.mark.skip(reason="Async API server uses different health check mechanism")
def test_health_endpoint(test_client):
"""Test health check endpoint - skipped for async server"""
pass
def test_generate_single_image(test_client):
"""Test generating a single image"""
response = test_client.post(
"/v1/images/generations",
json={
"prompt": "a cat",
"n": 1,
"size": "1024x1024",
},
)
assert response.status_code == 200
data = response.json()
# Check response structure
assert "created" in data
assert isinstance(data["created"], int)
assert "data" in data
assert len(data["data"]) == 1
assert "b64_json" in data["data"][0]
# Verify image can be decoded
img_bytes = base64.b64decode(data["data"][0]["b64_json"])
img = Image.open(io.BytesIO(img_bytes))
assert img.size == (64, 64) # Our mock returns 64x64 images
def test_generate_multiple_images(test_client):
"""Test generating multiple images"""
response = test_client.post(
"/v1/images/generations",
json={
"prompt": "a dog",
"n": 3,
"size": "512x512",
},
)
assert response.status_code == 200
data = response.json()
assert len(data["data"]) == 3
# All images should be valid
for img_data in data["data"]:
assert "b64_json" in img_data
img_bytes = base64.b64decode(img_data["b64_json"])
img = Image.open(io.BytesIO(img_bytes))
assert img.format == "PNG"
def test_with_negative_prompt(test_client):
"""Test with negative prompt"""
response = test_client.post(
"/v1/images/generations",
json={
"prompt": "beautiful landscape",
"negative_prompt": "blurry, low quality",
"size": "1024x1024",
},
)
assert response.status_code == 200
def test_with_seed(test_client):
"""Test with seed for reproducibility"""
response = test_client.post(
"/v1/images/generations",
json={
"prompt": "a tree",
"seed": 42,
"size": "1024x1024",
},
)
assert response.status_code == 200
def test_with_custom_parameters(test_client):
"""Test with custom diffusion parameters"""
response = test_client.post(
"/v1/images/generations",
json={
"prompt": "a mountain",
"size": "1024x1024",
"num_inference_steps": 100,
"true_cfg_scale": 5.5,
"seed": 123,
},
)
assert response.status_code == 200
def test_invalid_size(test_client):
"""Test with invalid size parameter - rejected by Pydantic"""
response = test_client.post(
"/v1/images/generations",
json={
"prompt": "a cat",
"size": "invalid",
},
)
# Pydantic validation errors return 422 (Unprocessable Entity)
# "invalid" has no "x" so Pydantic rejects it
assert response.status_code == 422
# Check error detail contains size validation message
detail = str(response.json()["detail"])
assert "size" in detail.lower() or "invalid" in detail.lower()
def test_invalid_size_parse_error(test_client):
"""Test with malformed size - passes Pydantic but fails parse_size()"""
response = test_client.post(
"/v1/images/generations",
json={
"prompt": "a cat",
"size": "1024x", # Has "x" so Pydantic accepts, but parse_size() rejects
},
)
# parse_size() raises ValueError → endpoint converts to 400 (Bad Request)
assert response.status_code == 400
detail = str(response.json()["detail"])
assert "size" in detail.lower() or "invalid" in detail.lower()
def test_missing_prompt(test_client):
"""Test with missing required prompt field"""
response = test_client.post(
"/v1/images/generations",
json={
"size": "1024x1024",
},
)
# Pydantic validation error
assert response.status_code == 422
def test_invalid_n_parameter(test_client):
"""Test with invalid n parameter (out of range)"""
# n < 1
response = test_client.post(
"/v1/images/generations",
json={
"prompt": "a cat",
"n": 0,
},
)
assert response.status_code == 422
# n > 10
response = test_client.post(
"/v1/images/generations",
json={
"prompt": "a cat",
"n": 11,
},
)
assert response.status_code == 422
def test_url_response_format_not_supported(test_client):
"""Test that URL format returns error"""
response = test_client.post(
"/v1/images/generations",
json={
"prompt": "a cat",
"response_format": "url",
},
)
# Pydantic validation errors return 422 (Unprocessable Entity)
assert response.status_code == 422
# Check error mentions response_format or b64_json
detail = str(response.json()["detail"])
assert "b64_json" in detail.lower() or "response" in detail.lower()
def test_model_not_loaded():
"""Test error when diffusion engine is not initialized"""
from fastapi import FastAPI
from vllm_omni.entrypoints.openai.api_server import router
app = FastAPI()
app.include_router(router)
# Don't set diffusion_engine to simulate uninitialized state
app.state.diffusion_engine = None
client = TestClient(app)
response = client.post(
"/v1/images/generations",
json={
"prompt": "a cat",
},
)
assert response.status_code == 503
assert "not initialized" in response.json()["detail"].lower()
def test_different_image_sizes(test_client):
"""Test various valid image sizes"""
sizes = ["256x256", "512x512", "1024x1024", "1792x1024", "1024x1792"]
for size in sizes:
response = test_client.post(
"/v1/images/generations",
json={
"prompt": "a test image",
"size": size,
},
)
assert response.status_code == 200, f"Failed for size {size}"
def test_parameter_validation():
"""Test Pydantic model validation"""
from vllm_omni.entrypoints.openai.protocol.images import ImageGenerationRequest
# Valid request - optional parameters default to None
req = ImageGenerationRequest(prompt="test")
assert req.prompt == "test"
assert req.n == 1
assert req.model is None
assert req.size is None # Engine will use model defaults
assert req.num_inference_steps is None # Engine will use model defaults
assert req.true_cfg_scale is None # Engine will use model defaults
# Invalid num_inference_steps (out of range)
with pytest.raises(ValueError):
ImageGenerationRequest(prompt="test", num_inference_steps=0)
with pytest.raises(ValueError):
ImageGenerationRequest(prompt="test", num_inference_steps=201)
# Invalid guidance_scale (out of range)
with pytest.raises(ValueError):
ImageGenerationRequest(prompt="test", guidance_scale=-1.0)
with pytest.raises(ValueError):
ImageGenerationRequest(prompt="test", guidance_scale=21.0)
# Pass-Through Tests
def test_parameters_passed_through(test_client, mock_async_diffusion):
"""Verify all parameters passed through without modification"""
response = test_client.post(
"/v1/images/generations",
json={
"prompt": "test",
"num_inference_steps": 100,
"guidance_scale": 7.5,
"true_cfg_scale": 3.0,
"seed": 42,
},
)
assert response.status_code == 200
# Ensure generate() was called exactly once
mock_async_diffusion.generate.assert_awaited_once()
call_kwargs = mock_async_diffusion.generate.call_args[1]
assert call_kwargs["num_inference_steps"] == 100
assert call_kwargs["guidance_scale"] == 7.5
assert call_kwargs["true_cfg_scale"] == 3.0
assert call_kwargs["seed"] == 42
def test_optional_parameters_omitted(test_client, mock_async_diffusion):
"""Verify optional parameters not passed when omitted"""
response = test_client.post(
"/v1/images/generations",
json={
"prompt": "test",
"size": "512x512",
},
)
assert response.status_code == 200
# Ensure generate() was called exactly once
mock_async_diffusion.generate.assert_awaited_once()
call_kwargs = mock_async_diffusion.generate.call_args[1]
assert "num_inference_steps" not in call_kwargs
assert "guidance_scale" not in call_kwargs
assert "true_cfg_scale" not in call_kwargs
def test_model_field_omitted_works(test_client):
"""Test that omitting model field works"""
response = test_client.post(
"/v1/images/generations",
json={
"prompt": "test",
"size": "1024x1024",
# model field omitted
},
)
assert response.status_code == 200
@@ -0,0 +1,333 @@
# SPDX-License-Identifier: Apache-2.0
"""
Unit tests for OmniOpenAIServingChat sampling params handling.
Tests that standard OpenAI API parameters (max_tokens, temperature, etc.)
are correctly applied to the comprehension stage while preserving YAML defaults.
"""
from unittest.mock import MagicMock
import pytest
from vllm.sampling_params import SamplingParams
@pytest.fixture
def mock_comprehension_stage():
"""Create a mock comprehension stage with is_comprehension=True."""
stage = MagicMock()
stage.is_comprehension = True
stage.model_stage = "comprehension"
return stage
@pytest.fixture
def mock_other_stage():
"""Create a mock non-comprehension stage."""
stage = MagicMock()
stage.is_comprehension = False
stage.model_stage = "other"
return stage
@pytest.fixture
def default_comprehension_params():
"""Default sampling params for comprehension stage (from YAML)."""
return SamplingParams(
temperature=0.4,
top_p=0.9,
top_k=1,
max_tokens=2048,
seed=42,
repetition_penalty=1.05,
)
@pytest.fixture
def default_other_params():
"""Default sampling params for non-comprehension stage (from YAML)."""
return SamplingParams(
temperature=0.9,
top_k=50,
max_tokens=4096,
seed=42,
)
@pytest.fixture
def mock_engine_client(mock_comprehension_stage, mock_other_stage, default_comprehension_params, default_other_params):
"""Create mock engine client with stage_list and default_sampling_params_list."""
engine_client = MagicMock()
engine_client.stage_list = [mock_comprehension_stage, mock_other_stage]
engine_client.default_sampling_params_list = [
default_comprehension_params,
default_other_params,
]
return engine_client
@pytest.fixture
def serving_chat(mock_engine_client):
"""Create OmniOpenAIServingChat instance with mocked dependencies."""
from vllm_omni.entrypoints.openai.serving_chat import OmniOpenAIServingChat
# Create instance without calling __init__
instance = object.__new__(OmniOpenAIServingChat)
instance.engine_client = mock_engine_client
return instance
@pytest.fixture
def mock_request():
"""Create a mock request with all OpenAI sampling params set to None."""
request = MagicMock()
# OpenAI standard sampling fields
request.temperature = None
request.top_p = None
request.max_tokens = None
request.seed = None
request.stop = None
request.frequency_penalty = None
request.presence_penalty = None
return request
# =============================================================================
# Tests for _OPENAI_SAMPLING_FIELDS constant
# =============================================================================
def test_openai_sampling_fields_contains_expected_fields():
"""Test that _OPENAI_SAMPLING_FIELDS contains all expected OpenAI params."""
from vllm_omni.entrypoints.openai.serving_chat import OmniOpenAIServingChat
expected_fields = {
"temperature",
"top_p",
"max_tokens",
"seed",
"stop",
"frequency_penalty",
"presence_penalty",
}
assert OmniOpenAIServingChat._OPENAI_SAMPLING_FIELDS == expected_fields
# =============================================================================
# Tests for _build_sampling_params_list_from_request
# =============================================================================
def test_preserves_yaml_defaults_when_no_request_params(serving_chat, mock_request):
"""Test that YAML defaults are preserved when request has no params."""
result = serving_chat._build_sampling_params_list_from_request(mock_request)
assert len(result) == 2
comprehension_params = result[0]
assert comprehension_params.temperature == 0.4
assert comprehension_params.top_p == 0.9
assert comprehension_params.top_k == 1 # YAML custom param preserved
assert comprehension_params.max_tokens == 2048
assert comprehension_params.seed == 42
assert comprehension_params.repetition_penalty == 1.05 # YAML custom param preserved
def test_request_temperature_overrides_yaml_default(serving_chat, mock_request):
"""Test that request temperature overrides YAML default."""
mock_request.temperature = 0.8
result = serving_chat._build_sampling_params_list_from_request(mock_request)
comprehension_params = result[0]
assert comprehension_params.temperature == 0.8 # Overridden
assert comprehension_params.seed == 42 # Preserved from YAML
assert comprehension_params.top_k == 1 # YAML custom param preserved
def test_request_top_p_overrides_yaml_default(serving_chat, mock_request):
"""Test that request top_p overrides YAML default."""
mock_request.top_p = 0.95
result = serving_chat._build_sampling_params_list_from_request(mock_request)
comprehension_params = result[0]
assert comprehension_params.top_p == 0.95 # Overridden
assert comprehension_params.temperature == 0.4 # Preserved from YAML
def test_request_max_tokens_overrides_yaml_default(serving_chat, mock_request):
"""Test that request max_tokens overrides YAML default."""
mock_request.max_tokens = 100
result = serving_chat._build_sampling_params_list_from_request(mock_request)
assert result[0].max_tokens == 100
def test_max_tokens_uses_yaml_default_when_not_specified(serving_chat, mock_request):
"""Test that max_tokens falls back to YAML default when not in request."""
result = serving_chat._build_sampling_params_list_from_request(mock_request)
assert result[0].max_tokens == 2048
def test_request_seed_overrides_yaml_default(serving_chat, mock_request):
"""Test that request seed overrides YAML default."""
mock_request.seed = 123
result = serving_chat._build_sampling_params_list_from_request(mock_request)
comprehension_params = result[0]
assert comprehension_params.seed == 123 # Overridden
assert comprehension_params.temperature == 0.4 # Preserved from YAML
def test_request_frequency_penalty_overrides(serving_chat, mock_request):
"""Test that request frequency_penalty is applied."""
mock_request.frequency_penalty = 0.5
result = serving_chat._build_sampling_params_list_from_request(mock_request)
assert result[0].frequency_penalty == 0.5
def test_request_presence_penalty_overrides(serving_chat, mock_request):
"""Test that request presence_penalty is applied."""
mock_request.presence_penalty = 0.3
result = serving_chat._build_sampling_params_list_from_request(mock_request)
assert result[0].presence_penalty == 0.3
def test_non_comprehension_stages_use_cloned_defaults(serving_chat, mock_request):
"""Test that non-comprehension stages always use cloned YAML defaults."""
mock_request.max_tokens = 50
mock_request.temperature = 0.1
result = serving_chat._build_sampling_params_list_from_request(mock_request)
other_params = result[1]
assert other_params.temperature == 0.9 # YAML default (not affected by request)
assert other_params.max_tokens == 4096 # YAML default (not affected by request)
assert other_params.top_k == 50 # YAML default
assert other_params.seed == 42 # YAML default
def test_multiple_params_override_together(serving_chat, mock_request):
"""Test that multiple request params can override together."""
mock_request.max_tokens = 200
mock_request.temperature = 0.7
mock_request.top_p = 0.85
mock_request.seed = 999
result = serving_chat._build_sampling_params_list_from_request(mock_request)
comprehension_params = result[0]
# Overridden by request
assert comprehension_params.temperature == 0.7
assert comprehension_params.top_p == 0.85
assert comprehension_params.max_tokens == 200
assert comprehension_params.seed == 999
# Preserved from YAML (not in _OPENAI_SAMPLING_FIELDS)
assert comprehension_params.top_k == 1
assert comprehension_params.repetition_penalty == 1.05
def test_yaml_custom_params_not_overridden_by_request(serving_chat, mock_request):
"""Test that YAML custom params (top_k, repetition_penalty) are not affected."""
# Even if request has these attributes, they should not override YAML
# because they're not in _OPENAI_SAMPLING_FIELDS
mock_request.top_k = 100 # Not in allowlist
mock_request.repetition_penalty = 2.0 # Not in allowlist
result = serving_chat._build_sampling_params_list_from_request(mock_request)
comprehension_params = result[0]
assert comprehension_params.top_k == 1 # YAML default preserved
assert comprehension_params.repetition_penalty == 1.05 # YAML default preserved
# =============================================================================
# Tests for _apply_request_overrides
# =============================================================================
def test_apply_request_overrides_clones_params(serving_chat, mock_request, default_comprehension_params):
"""Test that _apply_request_overrides returns a cloned object."""
result = serving_chat._apply_request_overrides(default_comprehension_params, mock_request)
assert result is not default_comprehension_params # Different object
def test_apply_request_overrides_preserves_defaults(serving_chat, mock_request, default_comprehension_params):
"""Test that _apply_request_overrides preserves defaults when request has None."""
result = serving_chat._apply_request_overrides(default_comprehension_params, mock_request)
assert result.temperature == 0.4
assert result.top_p == 0.9
assert result.seed == 42
assert result.top_k == 1 # YAML custom param
def test_apply_request_overrides_applies_values(serving_chat, mock_request, default_comprehension_params):
"""Test that _apply_request_overrides applies non-None request values."""
mock_request.temperature = 0.8
mock_request.seed = 123
result = serving_chat._apply_request_overrides(default_comprehension_params, mock_request)
assert result.temperature == 0.8 # Overridden
assert result.seed == 123 # Overridden
assert result.top_p == 0.9 # Preserved from default
assert result.top_k == 1 # YAML custom param preserved
# =============================================================================
# Tests for _get_comprehension_stage_index
# =============================================================================
def test_get_comprehension_stage_index_finds_first_stage(mock_engine_client):
"""Test finding comprehension stage when it's at index 0."""
from vllm_omni.entrypoints.openai.serving_chat import OmniOpenAIServingChat
instance = object.__new__(OmniOpenAIServingChat)
instance.engine_client = mock_engine_client
assert instance._get_comprehension_stage_index() == 0
def test_get_comprehension_stage_index_finds_second_stage():
"""Test finding comprehension stage when it's at index 1."""
from vllm_omni.entrypoints.openai.serving_chat import OmniOpenAIServingChat
instance = object.__new__(OmniOpenAIServingChat)
other = MagicMock()
other.is_comprehension = False
comprehension = MagicMock()
comprehension.is_comprehension = True
instance.engine_client = MagicMock()
instance.engine_client.stage_list = [other, comprehension]
assert instance._get_comprehension_stage_index() == 1
def test_get_comprehension_stage_index_raises_when_not_found():
"""Test that ValueError is raised when no comprehension stage exists."""
from vllm_omni.entrypoints.openai.serving_chat import OmniOpenAIServingChat
instance = object.__new__(OmniOpenAIServingChat)
stage1 = MagicMock()
stage1.is_comprehension = False
stage2 = MagicMock()
stage2.is_comprehension = False
instance.engine_client = MagicMock()
instance.engine_client.stage_list = [stage1, stage2]
with pytest.raises(ValueError, match="No comprehension stage"):
instance._get_comprehension_stage_index()