fix: return proper HTTP status codes for audio voice endpoints (#3969)

Signed-off-by: Ian Eaves <ian.k.eaves@gmail.com>
Signed-off-by: Yueqian Lin <linyueqian@outlook.com>
Co-authored-by: Yueqian Lin <linyueqian@outlook.com>
Co-authored-by: Yueqian Lin <70319226+linyueqian@users.noreply.github.com>
This commit is contained in:
authored and GitHub committed 2026-06-22 22:57:07 +00:00
1 parent 044240d8eb
commit 50bc51ffdf
3 files changed
+340 -61

No files matched your search

+96 -29
View File
@@ -347,6 +347,38 @@ def _create_engine_error_json_response(
return JSONResponse(content=payload, status_code=status_code)
def _error_response_to_json_response(
err: ErrorResponse,
*,
status_code: HTTPStatus | int | None = None,
default_status_code: HTTPStatus | int = HTTPStatus.BAD_REQUEST,
) -> JSONResponse:
resolved_status = int(
status_code
if status_code is not None
else (err.error.code if err.error and err.error.code is not None else default_status_code)
)
payload = err.model_dump()
if err.error:
payload["error"]["code"] = resolved_status
return JSONResponse(content=payload, status_code=resolved_status)
def _create_speech_error_json_response(
raw_request: Request,
message: str,
*,
err_type: str = "BadRequestError",
status_code: HTTPStatus = HTTPStatus.BAD_REQUEST,
) -> JSONResponse:
err = base(raw_request).create_error_response(
message=message,
err_type=err_type,
status_code=status_code,
)
return _error_response_to_json_response(err, status_code=status_code)
class _DiffusionServingModels:
"""Minimal OpenAIServingModels implementation for diffusion-only servers.
@@ -1231,14 +1263,16 @@ async def create_speech(request: OpenAICreateSpeechRequest, raw_request: Request
status_code=HTTPStatus.NOT_FOUND.value,
detail="The model does not support Speech API",
)
return base_server.create_error_response(message="The model does not support Speech API")
err = base_server.create_error_response(
message="The model does not support Speech API",
err_type="NotFoundError",
status_code=HTTPStatus.NOT_FOUND,
)
return _error_response_to_json_response(err, status_code=HTTPStatus.NOT_FOUND)
try:
result = await handler.create_speech(request, raw_request)
if isinstance(result, ErrorResponse):
return JSONResponse(
content=result.model_dump(),
status_code=result.error.code if result.error else 400,
)
return _error_response_to_json_response(result)
return result
except (EngineGenerateError, EngineDeadError) as exc:
return _create_engine_error_json_response(raw_request, exc)
@@ -1267,14 +1301,16 @@ async def create_speech_batch(request: BatchSpeechRequest, raw_request: Request)
status_code=HTTPStatus.NOT_FOUND.value,
detail="The model does not support Speech API",
)
return base_server.create_error_response(message="The model does not support Speech API")
err = base_server.create_error_response(
message="The model does not support Speech API",
err_type="NotFoundError",
status_code=HTTPStatus.NOT_FOUND,
)
return _error_response_to_json_response(err, status_code=HTTPStatus.NOT_FOUND)
try:
result = await handler.create_speech_batch(request)
if isinstance(result, ErrorResponse):
return JSONResponse(
content=result.model_dump(),
status_code=result.error.code if result.error else 400,
)
return _error_response_to_json_response(result)
return JSONResponse(content=result.model_dump())
except (EngineGenerateError, EngineDeadError) as exc:
return _create_engine_error_json_response(raw_request, exc)
@@ -1305,14 +1341,16 @@ async def create_audio_generate(request: OpenAICreateAudioGenerateRequest, raw_r
status_code=HTTPStatus.NOT_FOUND.value,
detail="The model does not support Audio Generate API",
)
return base_server.create_error_response(message="The model does not support Audio Generate API")
err = base_server.create_error_response(
message="The model does not support Audio Generate API",
err_type="NotFoundError",
status_code=HTTPStatus.NOT_FOUND,
)
return _error_response_to_json_response(err, status_code=HTTPStatus.NOT_FOUND)
try:
result = await handler.create_audio_generate(request, raw_request)
if isinstance(result, ErrorResponse):
return JSONResponse(
content=result.model_dump(),
status_code=result.error.code if result.error else 400,
)
return _error_response_to_json_response(result)
return result
except (EngineGenerateError, EngineDeadError) as exc:
return _create_engine_error_json_response(raw_request, exc)
@@ -1342,7 +1380,12 @@ async def list_voices(raw_request: Request):
"""
handler = Omnispeech(raw_request)
if handler is None:
return base(raw_request).create_error_response(message="The model does not support Speech API")
return _create_speech_error_json_response(
raw_request,
"The model does not support Speech API",
err_type="NotFoundError",
status_code=HTTPStatus.NOT_FOUND,
)
# Get all speakers (both model built-in and uploaded)
speakers = sorted(handler.supported_speakers) if handler.supported_speakers else []
@@ -1374,6 +1417,7 @@ async def list_voices(raw_request: Request):
responses={
HTTPStatus.OK.value: {"model": dict},
HTTPStatus.BAD_REQUEST.value: {"model": ErrorResponse},
HTTPStatus.NOT_FOUND.value: {"model": ErrorResponse},
HTTPStatus.INTERNAL_SERVER_ERROR.value: {"model": ErrorResponse},
},
)
@@ -1415,12 +1459,17 @@ async def upload_voice(
"""
handler = Omnispeech(raw_request)
if handler is None:
return base(raw_request).create_error_response(message="The model does not support Speech API")
return _create_speech_error_json_response(
raw_request,
"The model does not support Speech API",
err_type="NotFoundError",
status_code=HTTPStatus.NOT_FOUND,
)
try:
if speaker_embedding is not None and audio_sample is not None:
return base(raw_request).create_error_response(
message="'audio_sample' and 'speaker_embedding' are mutually exclusive"
return _create_speech_error_json_response(
raw_request, "'audio_sample' and 'speaker_embedding' are mutually exclusive"
)
if speaker_embedding is not None:
result = await handler.upload_voice_embedding(speaker_embedding, consent, name)
@@ -1433,23 +1482,29 @@ async def upload_voice(
speaker_description=speaker_description,
)
else:
return base(raw_request).create_error_response(
message="Either 'audio_sample' or 'speaker_embedding' must be provided"
return _create_speech_error_json_response(
raw_request, "Either 'audio_sample' or 'speaker_embedding' must be provided"
)
return JSONResponse(content={"success": True, "voice": result})
except ValueError as e:
return base(raw_request).create_error_response(message=str(e))
return _create_speech_error_json_response(raw_request, str(e))
except Exception as e:
logger.exception(f"Failed to upload voice: {e}")
return base(raw_request).create_error_response(message=f"Failed to upload voice: {str(e)}")
return _create_speech_error_json_response(
raw_request,
f"Failed to upload voice: {str(e)}",
err_type="InternalServerError",
status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
)
@router.delete(
"/v1/audio/voices/{name}",
responses={
HTTPStatus.OK.value: {"model": dict},
HTTPStatus.BAD_REQUEST.value: {"model": ErrorResponse},
HTTPStatus.NOT_FOUND.value: {"model": ErrorResponse},
HTTPStatus.INTERNAL_SERVER_ERROR.value: {"model": ErrorResponse},
},
@@ -1469,24 +1524,36 @@ async def delete_voice(name: str, raw_request: Request):
"""
handler = Omnispeech(raw_request)
if handler is None:
return base(raw_request).create_error_response(message="The model does not support Speech API")
return _create_speech_error_json_response(
raw_request,
"The model does not support Speech API",
err_type="NotFoundError",
status_code=HTTPStatus.NOT_FOUND,
)
try:
# Delete the voice
success = await handler.delete_voice(name)
if not success:
return JSONResponse(
content={"success": False, "error": f"Voice '{name}' not found"},
status_code=HTTPStatus.NOT_FOUND.value,
return _create_speech_error_json_response(
raw_request,
f"Voice '{name}' not found",
err_type="NotFoundError",
status_code=HTTPStatus.NOT_FOUND,
)
return JSONResponse(content={"success": True, "message": f"Voice '{name}' deleted successfully"})
except ValueError as e:
return base(raw_request).create_error_response(message=str(e))
return _create_speech_error_json_response(raw_request, str(e))
except Exception as e:
logger.exception(f"Failed to delete voice '{name}': {e}")
return base(raw_request).create_error_response(message=f"Failed to delete voice: {str(e)}")
return _create_speech_error_json_response(
raw_request,
f"Failed to delete voice: {str(e)}",
err_type="InternalServerError",
status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
)
@router.websocket("/v1/audio/speech/stream")