Failed to save combined model #285

Args:
    request: Either a string with voices separated by + (e.g. "voice1+voice2")
            or a list of voice names to combine

Returns:
    FileResponse with the combined voice .pt file

Raises:
    HTTPException:
        - 400: Invalid request (wrong number of voices, voice not found)
        - 500: Server error (file system issues, combination failed)
"""
# Check if local voice saving is allowed
if not settings.allow_local_voice_saving:
    raise HTTPException(
        status_code=403,
        detail={
            "error": "permission_denied",
            "message": "Local voice saving is disabled",
            "type": "permission_error",
        },
    )

try:
    # Convert input to list of voices
    if isinstance(request, str):
        # Check if it's an OpenAI voice name
        mapped_voice = _openai_mappings["voices"].get(request)
        if mapped_voice:
            request = mapped_voice
        voices = [v.strip() for v in request.split("+") if v.strip()]
    else:
        # For list input, map each voice if it's an OpenAI voice name
        voices = [_openai_mappings["voices"].get(v, v) for v in request]
        voices = [v.strip() for v in voices if v.strip()]

    if not voices:
        raise ValueError("No voices provided")

    # For multiple voices, validate base voices exist
    tts_service = await get_tts_service()
    available_voices = await tts_service.list_voices()
    for voice in voices:
        if voice not in available_voices:
            raise ValueError(
                f"Base voice '{voice}' not found. Available voices: {', '.join(sorted(available_voices))}"
            )

    # Combine voices
    combined_tensor = await tts_service.combine_voices(voices=voices)
    combined_name = "+".join(voices)

    # Save to temp file
    temp_dir = tempfile.gettempdir()
    voice_path = os.path.join(temp_dir, f"{combined_name}.pt")
    buffer = io.BytesIO()
    torch.save(combined_tensor, buffer)
    async with aiofiles.open(voice_path, "wb") as f:
        await f.write(buffer.getvalue())

    return FileResponse(
        voice_path,
        media_type="application/octet-stream",
        filename=f"{combined_name}.pt",
        headers={
            "Content-Disposition": f"attachment; filename={combined_name}.pt",
            "Cache-Control": "no-cache",
        },
    )

except ValueError as e:
    logger.warning(f"Invalid voice combination request: {str(e)}")
    raise HTTPException(
        status_code=400,
        detail={
            "error": "validation_error",
            "message": str(e),
            "type": "invalid_request_error",
        },
    )
except RuntimeError as e:
    logger.error(f"Voice combination processing error: {str(e)}")
    raise HTTPException(
        status_code=500,
        detail={
            "error": "processing_error",
            "message": "Failed to process voice combination request",
            "type": "server_error",
        },
    )
except Exception as e:
    logger.error(f"Unexpected error in voice combination: {str(e)}")
    raise HTTPException(
        status_code=500,
        detail={
            "error": "server_error",
            "message": "An unexpected error occurred",
            "type": "server_error",
        },
    )